177 files changed, 62383 insertions, 0 deletions

diff --git a/src/contrib/Makefile.am b/src/contrib/Makefile.am
new file mode 100644
index 000000000..abaefb409
--- /dev/null
+++ b/src/contrib/Makefile.am
@@ -0,0 +1,3 @@
+SUBDIRS = \
+        service \
+        cli
diff --git a/src/contrib/cli/Makefile.am b/src/contrib/cli/Makefile.am
new file mode 100644
index 000000000..3315e4bbb
--- /dev/null
+++ b/src/contrib/cli/Makefile.am
@@ -0,0 +1,2 @@
+SUBDIRS = \
+        template
diff --git a/src/contrib/cli/meson.build b/src/contrib/cli/meson.build
new file mode 100644
index 000000000..26b120864
--- /dev/null
+++ b/src/contrib/cli/meson.build
@@ -0,0 +1 @@
+subdir('template')
diff --git a/src/contrib/cli/template/.gitignore b/src/contrib/cli/template/.gitignore
new file mode 100644
index 000000000..6ace894c0
--- /dev/null
+++ b/src/contrib/cli/template/.gitignore
@@ -0,0 +1 @@
+gnunet-template
diff --git a/src/contrib/cli/template/Makefile.am b/src/contrib/cli/template/Makefile.am
new file mode 100644
index 000000000..b60095d80
--- /dev/null
+++ b/src/contrib/cli/template/Makefile.am
@@ -0,0 +1,21 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+if USE_COVERAGE
+  AM_CFLAGS = -fprofile-arcs -ftest-coverage
+endif
+
+noinst_PROGRAMS = \
+ gnunet-template
+
+
+gnunet_template_SOURCES = \
+ gnunet-template.c
+gnunet_template_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
+gnunet_template_LDFLAGS = \
+  $(GN_LIBINTL)
diff --git a/src/contrib/cli/template/gnunet-template.c b/src/contrib/cli/template/gnunet-template.c
new file mode 100644
index 000000000..5e250bbdf
--- /dev/null
+++ b/src/contrib/cli/template/gnunet-template.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 template/gnunet-template.c
+ * @brief template for writing a tool
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+/* #include "gnunet_template_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-template",
+                                          gettext_noop ("help text"),
+                                          options,
+                                          &run,
+                                          NULL))
+        ? ret
+        : 1;
+  GNUNET_free_nz ((void *) argv);
+  return ret;
+}
+
+
+/* end of gnunet-template.c */
diff --git a/src/contrib/cli/template/meson.build b/src/contrib/cli/template/meson.build
new file mode 100644
index 000000000..dba66a8f2
--- /dev/null
+++ b/src/contrib/cli/template/meson.build
@@ -0,0 +1,5 @@
+executable ('gnunet-template',
+            ['gnunet-template.c'],
+            dependencies: [libgnunetutil_dep],
+            include_directories: [incdir, configuration_inc],
+            install: false)
diff --git a/src/contrib/meson.build b/src/contrib/meson.build
new file mode 100644
index 000000000..e856ea7ef
--- /dev/null
+++ b/src/contrib/meson.build
@@ -0,0 +1,5 @@
+#subdir('lib')
+subdir('service')
+#subdir('plugin')
+#subdir('rest-plugin')
+subdir('cli')
diff --git a/src/contrib/service/Makefile.am b/src/contrib/service/Makefile.am
new file mode 100644
index 000000000..2d365106b
--- /dev/null
+++ b/src/contrib/service/Makefile.am
@@ -0,0 +1,23 @@
+if HAVE_EXPERIMENTAL
+ EXP_DIR = \
+  rps \
+  abd \
+  auction
+endif
+
+if BUILD_PULSE_HELPERS
+CONVERSATION_DIR = conversation
+else
+if BUILD_GST_HELPERS
+CONVERSATION_DIR = conversation
+endif
+endif
+
+SUBDIRS = \
+        template \
+        set \
+        consensus \
+        secretsharing \
+        scalarproduct \
+  $(CONVERSATION_DIR) \
+        $(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..f199d72ed
--- /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/service/identity/libgnunetidentity.la \
+  $(top_builddir)/src/service/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/service/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/service/gns/libgnunetgns.la \
+        $(top_builddir)/src/service/namestore/libgnunetnamestore.la \
+  $(top_builddir)/src/service/identity/libgnunetidentity.la \
+  $(top_builddir)/src/service/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/service/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..50a0a907c
--- /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/consensus/.gitignore b/src/contrib/service/consensus/.gitignore
new file mode 100644
index 000000000..8050d760e
--- /dev/null
+++ b/src/contrib/service/consensus/.gitignore
@@ -0,0 +1,6 @@
+gnunet-service-evil-consensus
+gnunet-consensus-profiler
+gnunet-service-consensus
+test_consensus_api
+resource.log.master
+consensus-simulation.py
diff --git a/src/contrib/service/consensus/Makefile.am b/src/contrib/service/consensus/Makefile.am
new file mode 100644
index 000000000..6b4db05fc
--- /dev/null
+++ b/src/contrib/service/consensus/Makefile.am
@@ -0,0 +1,106 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+plugindir = $(libdir)/gnunet
+
+pkgcfg_DATA = \
+  consensus.conf
+
+if USE_COVERAGE
+  AM_CFLAGS = -fprofile-arcs -ftest-coverage
+endif
+
+
+libexec_PROGRAMS = \
+ gnunet-service-consensus
+
+if ENABLE_MALICIOUS
+libexec_PROGRAMS += \
+ gnunet-service-evil-consensus
+endif
+
+SUFFIXES = .py.in .py
+
+.py.in.py:
+        $(AWK) -v bdir="$(bindir)" -v py="$(PYTHON)" -v awkay="$(AWK_BINARY)" -v pfx="$(prefix)" -v prl="$(PERL)" -v sysconfdirectory="$(sysconfdir)" -v pkgdatadirectory="$(pkgdatadir)" -f $(top_srcdir)/scripts/dosubst.awk < $< > $@
+        chmod +x $@
+
+check-python-style:
+        flake8 consensus-simulation.py.in
+
+lib_LTLIBRARIES = \
+  libgnunetconsensus.la
+
+gnunet_service_consensus_SOURCES = \
+ gnunet-service-consensus.c
+gnunet_service_consensus_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/service/core/libgnunetcore.la \
+  $(top_builddir)/src/contrib/service/set/libgnunetset.la \
+  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(GN_LIBINTL)
+
+gnunet_service_evil_consensus_SOURCES = \
+ gnunet-service-consensus.c \
+ consensus_protocol.h
+gnunet_service_evil_consensus_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/service/core/libgnunetcore.la \
+  $(top_builddir)/src/contrib/service/set/libgnunetset.la \
+  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(GN_LIBINTL)
+gnunet_service_evil_consensus_CFLAGS = -DEVIL
+
+libgnunetconsensus_la_SOURCES = \
+  consensus_api.c \
+  consensus.h
+libgnunetconsensus_la_LIBADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunetconsensus_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)
+
+
+plugin_LTLIBRARIES = \
+  libgnunet_plugin_block_consensus.la
+
+libgnunet_plugin_block_consensus_la_SOURCES = \
+  plugin_block_consensus.c
+libgnunet_plugin_block_consensus_la_LIBADD = \
+  $(top_builddir)/src/lib/block/libgnunetblock.la \
+  $(top_builddir)/src/lib/block/libgnunetblockgroup.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunet_plugin_block_consensus_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
+
+
+
+check_PROGRAMS = \
+ test_consensus_api
+
+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_consensus_api_SOURCES = \
+ test_consensus_api.c
+test_consensus_api_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/service/testing/libgnunettesting.la \
+  libgnunetconsensus.la
+
+noinst_SCRIPTS = \
+        consensus-simulation.py
+
+CLEANFILES = \
+        $(noinst_SCRIPTS)
+
+EXTRA_DIST = \
+  test_consensus.conf \
+  consensus-simulation.py.in
diff --git a/src/contrib/service/consensus/consensus-simulation.py.in b/src/contrib/service/consensus/consensus-simulation.py.in
new file mode 100644
index 000000000..272a52da2
--- /dev/null
+++ b/src/contrib/service/consensus/consensus-simulation.py.in
@@ -0,0 +1,112 @@
+#!@PYTHONEXE@
+# This file is part of GNUnet
+# (C) 2013, 2018 Christian Grothoff (and other contributing authors)
+#
+# GNUnet is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License,
+# or (at your option) any later version.
+#
+# GNUnet is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: AGPL3.0-or-later
+
+import argparse
+import random
+from math import ceil, log, floor
+
+
+def bsc(n):
+    """ count the bits set in n"""
+    l = n.bit_length()
+    c = 0
+    x = 1
+    for _ in range(0, l):
+        if n & x:
+            c = c + 1
+        x = x << 1
+    return c
+
+
+def simulate(k, n, verbose):
+    assert k < n
+    largest_arc = int(2**ceil(log(n, 2))) // 2
+    num_ghosts = (2 * largest_arc) - n
+    if verbose:
+        print("we have", num_ghosts, "ghost peers")
+        # n.b. all peers with idx<k are evil
+    peers = list(range(n))
+    info = [1 << x for x in range(n)]
+
+    def done_p():
+        for x in range(k, n):
+            if bsc(info[x]) < n - k:
+                return False
+        return True
+
+    rounds = 0
+    while not done_p():
+        if verbose:
+            print("-- round --")
+        arc = 1
+        while arc <= largest_arc:
+            if verbose:
+                print("-- subround --")
+            new_info = [x for x in info]
+            for peer_physical in range(n):
+                peer_logical = peers[peer_physical]
+                peer_type = None
+                partner_logical = (peer_logical + arc) % n
+                partner_physical = peers.index(partner_logical)
+                if peer_physical < k or partner_physical < k:
+                    if verbose:
+                        print(
+                            "bad peer in connection", peer_physical, "--",
+                            partner_physical
+                        )
+                    continue
+                if peer_logical & arc == 0:
+                    # we are outgoing
+                    if verbose:
+                        print(peer_physical, "connects to", partner_physical)
+                    peer_type = "outgoing"
+                    if peer_logical < num_ghosts:
+                        # we have a ghost, check if the peer who connects
+                        # to our ghost is actually outgoing
+                        ghost_partner_logical = (peer_logical - arc) % n
+                        if ghost_partner_logical & arc == 0:
+                            peer_type = peer_type + ", ghost incoming"
+                    new_info[peer_physical] = new_info[peer_physical] | info[
+                        peer_physical] | info[partner_physical]
+                    new_info[partner_physical
+                             ] = new_info[partner_physical] | info[
+                                 peer_physical] | info[partner_physical]
+                else:
+                    peer_type = "incoming"
+                if verbose > 1:
+                    print("type of", str(peer_physical) + ":", peer_type)
+            info = new_info
+            arc = arc << 1
+        rounds = rounds + 1
+        random.shuffle(peers)
+    return rounds
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("k", metavar="k", type=int, help="#(bad peers)")
+    parser.add_argument("n", metavar="n", type=int, help="#(all peers)")
+    parser.add_argument("r", metavar="r", type=int, help="#(rounds)")
+    parser.add_argument('--verbose', '-v', action='count')
+
+    args = parser.parse_args()
+    sum = 0.0
+    for n in range(0, args.r):
+        sum += simulate(args.k, args.n, args.verbose)
+    print(sum // args.r)
diff --git a/src/contrib/service/consensus/consensus.conf.in b/src/contrib/service/consensus/consensus.conf.in
new file mode 100644
index 000000000..b0fbcaf5a
--- /dev/null
+++ b/src/contrib/service/consensus/consensus.conf.in
@@ -0,0 +1,10 @@
+[consensus]
+START_ON_DEMAND = @START_ON_DEMAND@
+@JAVAPORT@PORT = 2103
+HOSTNAME = localhost
+BINARY = gnunet-service-consensus
+ACCEPT_FROM = 127.0.0.1;
+ACCEPT_FROM6 = ::1;
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-consensus.sock
+UNIX_MATCH_UID = YES
+UNIX_MATCH_GID = YES
diff --git a/src/contrib/service/consensus/consensus.h b/src/contrib/service/consensus/consensus.h
new file mode 100644
index 000000000..888213d55
--- /dev/null
+++ b/src/contrib/service/consensus/consensus.h
@@ -0,0 +1,92 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2012 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @author Florian Dold
+ * @file consensus/consensus.h
+ * @brief
+ */
+#ifndef CONSENSUS_H
+#define CONSENSUS_H
+
+#include "gnunet_common.h"
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * Sent by the client to the service,
+ * when the client wants the service to join a consensus session.
+ */
+struct GNUNET_CONSENSUS_JoinMessage
+{
+  /**
+   * Type: GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_JOIN
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Number of peers (at the end of this message) that want to
+   * participate in the consensus.
+   */
+  uint32_t num_peers GNUNET_PACKED;
+
+  /**
+   * Session id of the consensus.
+   */
+  struct GNUNET_HashCode session_id;
+
+  /**
+   * Start time for the consensus.
+   */
+  struct GNUNET_TIME_AbsoluteNBO start;
+
+  /**
+   * Deadline for conclude.
+   */
+  struct GNUNET_TIME_AbsoluteNBO deadline;
+
+  /* GNUNET_PeerIdentity[num_peers] */
+};
+
+
+/**
+ * Message with an element
+ */
+struct GNUNET_CONSENSUS_ElementMessage
+{
+  /**
+   * Type:
+   * Either GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT
+   * or GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_INSERT_ELEMENT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Type: GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_NEW_ELEMENT
+   */
+  uint16_t element_type GNUNET_PACKED; /* FIXME: alignment? => uint32_t */
+
+  /* rest: element data */
+};
+
+
+GNUNET_NETWORK_STRUCT_END
+
+#endif
diff --git a/src/contrib/service/consensus/consensus_api.c b/src/contrib/service/consensus/consensus_api.c
new file mode 100644
index 000000000..01d0ad3de
--- /dev/null
+++ b/src/contrib/service/consensus/consensus_api.c
@@ -0,0 +1,346 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2012, 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 consensus/consensus_api.c
+ * @brief
+ * @author Florian Dold
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_consensus_service.h"
+#include "consensus.h"
+
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "consensus-api", __VA_ARGS__)
+
+
+/**
+ * Handle for the service.
+ */
+struct GNUNET_CONSENSUS_Handle
+{
+  /**
+   * Configuration to use.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Callback for new elements. Not called for elements added locally.
+   */
+  GNUNET_CONSENSUS_ElementCallback new_element_cb;
+
+  /**
+   * Closure for @e new_element_cb
+   */
+  void *new_element_cls;
+
+  /**
+   * The (local) session identifier for the consensus session.
+   */
+  struct GNUNET_HashCode session_id;
+
+  /**
+   * #GNUNET_YES iff the join message has been sent to the service.
+   */
+  int joined;
+
+  /**
+   * Called when the conclude operation finishes or fails.
+   */
+  GNUNET_CONSENSUS_ConcludeCallback conclude_cb;
+
+  /**
+   * Closure for the @e conclude_cb callback.
+   */
+  void *conclude_cls;
+
+  /**
+   * Deadline for the conclude operation.
+   */
+  struct GNUNET_TIME_Absolute conclude_deadline;
+
+  /**
+   * Message queue for the client.
+   */
+  struct GNUNET_MQ_Handle *mq;
+};
+
+
+/**
+ * FIXME: this should not bee necessary when the API
+ * issue has been fixed
+ */
+struct InsertDoneInfo
+{
+  GNUNET_CONSENSUS_InsertDoneCallback idc;
+  void *cls;
+};
+
+
+/**
+ * Called when the server has sent is a new element
+ *
+ * @param cls consensus handle
+ * @param msg element message
+ */
+static int
+check_new_element (void *cls,
+                   const struct GNUNET_CONSENSUS_ElementMessage *msg)
+{
+  /* any size is fine, elements are variable-size */
+  return GNUNET_OK;
+}
+
+
+/**
+ * Called when the server has sent is a new element
+ *
+ * @param cls consensus handle
+ * @param msg element message
+ */
+static void
+handle_new_element (void *cls,
+                    const struct GNUNET_CONSENSUS_ElementMessage *msg)
+{
+  struct GNUNET_CONSENSUS_Handle *consensus = cls;
+  struct GNUNET_SET_Element element;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "received new element\n");
+  element.element_type = msg->element_type;
+  element.size = ntohs (msg->header.size) - sizeof(struct
+                                                   GNUNET_CONSENSUS_ElementMessage);
+  element.data = &msg[1];
+  consensus->new_element_cb (consensus->new_element_cls,
+                             &element);
+}
+
+
+/**
+ * Called when the server has announced
+ * that the conclusion is over.
+ *
+ * @param cls consensus handle
+ * @param msg conclude done message
+ */
+static void
+handle_conclude_done (void *cls,
+                      const struct GNUNET_MessageHeader *msg)
+{
+  struct GNUNET_CONSENSUS_Handle *consensus = cls;
+  GNUNET_CONSENSUS_ConcludeCallback cc;
+
+  GNUNET_MQ_destroy (consensus->mq);
+  consensus->mq = NULL;
+  GNUNET_assert (NULL != (cc = consensus->conclude_cb));
+  consensus->conclude_cb = NULL;
+  cc (consensus->conclude_cls);
+}
+
+
+/**
+ * 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, same closure as for the message handlers
+ * @param error error code
+ */
+static void
+mq_error_handler (void *cls,
+                  enum GNUNET_MQ_Error error)
+{
+  LOG (GNUNET_ERROR_TYPE_WARNING,
+       "consensus service disconnected us\n");
+}
+
+
+/**
+ * Create a consensus session.
+ *
+ * @param cfg configuration to use for connecting to the consensus service
+ * @param num_peers number of peers in the peers array
+ * @param peers array of peers participating in this consensus session
+ *              Inclusion of the local peer is optional.
+ * @param session_id session identifier
+ *                   Allows a group of peers to have more than consensus session.
+ * @param start start time of the consensus, conclude should be called before
+ *              the start time.
+ * @param deadline time when the consensus should have concluded
+ * @param new_element_cb callback, called when a new element is added to the set by
+ *                    another peer
+ * @param new_element_cls closure for new_element
+ * @return handle to use, NULL on error
+ */
+struct GNUNET_CONSENSUS_Handle *
+GNUNET_CONSENSUS_create (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                         unsigned int num_peers,
+                         const struct GNUNET_PeerIdentity *peers,
+                         const struct GNUNET_HashCode *session_id,
+                         struct GNUNET_TIME_Absolute start,
+                         struct GNUNET_TIME_Absolute deadline,
+                         GNUNET_CONSENSUS_ElementCallback new_element_cb,
+                         void *new_element_cls)
+{
+  struct GNUNET_CONSENSUS_Handle *consensus
+    = GNUNET_new (struct GNUNET_CONSENSUS_Handle);
+  struct GNUNET_MQ_MessageHandler mq_handlers[] = {
+    GNUNET_MQ_hd_var_size (new_element,
+                           GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT,
+                           struct GNUNET_CONSENSUS_ElementMessage,
+                           consensus),
+    GNUNET_MQ_hd_fixed_size (conclude_done,
+                             GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE_DONE,
+                             struct GNUNET_MessageHeader,
+                             consensus),
+    GNUNET_MQ_handler_end ()
+  };
+  struct GNUNET_CONSENSUS_JoinMessage *join_msg;
+  struct GNUNET_MQ_Envelope *ev;
+
+  consensus->cfg = cfg;
+  consensus->new_element_cb = new_element_cb;
+  consensus->new_element_cls = new_element_cls;
+  consensus->session_id = *session_id;
+  consensus->mq = GNUNET_CLIENT_connect (cfg,
+                                         "consensus",
+                                         mq_handlers,
+                                         &mq_error_handler,
+                                         consensus);
+  if (NULL == consensus->mq)
+  {
+    GNUNET_free (consensus);
+    return NULL;
+  }
+  ev = GNUNET_MQ_msg_extra (join_msg,
+                            (num_peers * sizeof(struct GNUNET_PeerIdentity)),
+                            GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_JOIN);
+
+  join_msg->session_id = consensus->session_id;
+  join_msg->start = GNUNET_TIME_absolute_hton (start);
+  join_msg->deadline = GNUNET_TIME_absolute_hton (deadline);
+  join_msg->num_peers = htonl (num_peers);
+  GNUNET_memcpy (&join_msg[1],
+                 peers,
+                 num_peers * sizeof(struct GNUNET_PeerIdentity));
+
+  GNUNET_MQ_send (consensus->mq, ev);
+  return consensus;
+}
+
+
+static void
+idc_adapter (void *cls)
+{
+  struct InsertDoneInfo *i = cls;
+
+  i->idc (i->cls, GNUNET_OK);
+  GNUNET_free (i);
+}
+
+
+/**
+ * Insert an element in the set being reconsiled.  Must not be called after
+ * "GNUNET_CONSENSUS_conclude".
+ *
+ * @param consensus handle for the consensus session
+ * @param element the element to be inserted
+ * @param idc function called when we are done with this element and it
+ *            is thus allowed to call GNUNET_CONSENSUS_insert again
+ * @param idc_cls closure for 'idc'
+ */
+void
+GNUNET_CONSENSUS_insert (struct GNUNET_CONSENSUS_Handle *consensus,
+                         const struct GNUNET_SET_Element *element,
+                         GNUNET_CONSENSUS_InsertDoneCallback idc,
+                         void *idc_cls)
+{
+  struct GNUNET_CONSENSUS_ElementMessage *element_msg;
+  struct GNUNET_MQ_Envelope *ev;
+  struct InsertDoneInfo *i;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "inserting, size=%u\n", element->size);
+
+  ev = GNUNET_MQ_msg_extra (element_msg, element->size,
+                            GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_INSERT);
+
+  GNUNET_memcpy (&element_msg[1], element->data, element->size);
+
+  if (NULL != idc)
+  {
+    i = GNUNET_new (struct InsertDoneInfo);
+    i->idc = idc;
+    i->cls = idc_cls;
+    GNUNET_MQ_notify_sent (ev, idc_adapter, i);
+  }
+  GNUNET_MQ_send (consensus->mq, ev);
+}
+
+
+/**
+ * We are done with inserting new elements into the consensus;
+ * try to conclude the consensus within a given time window.
+ * After conclude has been called, no further elements may be
+ * inserted by the client.
+ *
+ * @param consensus consensus session
+ * @param conclude called when the conclusion was successful
+ * @param conclude_cls closure for the conclude callback
+ */
+void
+GNUNET_CONSENSUS_conclude (struct GNUNET_CONSENSUS_Handle *consensus,
+                           GNUNET_CONSENSUS_ConcludeCallback conclude,
+                           void *conclude_cls)
+{
+  struct GNUNET_MQ_Envelope *ev;
+
+  GNUNET_assert (NULL != conclude);
+  GNUNET_assert (NULL == consensus->conclude_cb);
+
+  consensus->conclude_cls = conclude_cls;
+  consensus->conclude_cb = conclude;
+
+  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE);
+  GNUNET_MQ_send (consensus->mq, ev);
+}
+
+
+/**
+ * Destroy a consensus handle (free all state associated with
+ * it, no longer call any of the callbacks).
+ *
+ * @param consensus handle to destroy
+ */
+void
+GNUNET_CONSENSUS_destroy (struct GNUNET_CONSENSUS_Handle *consensus)
+{
+  if (NULL != consensus->mq)
+  {
+    GNUNET_MQ_destroy (consensus->mq);
+    consensus->mq = NULL;
+  }
+  GNUNET_free (consensus);
+}
+
+
+/* end of consensus_api.c */
diff --git a/src/contrib/service/consensus/consensus_protocol.h b/src/contrib/service/consensus/consensus_protocol.h
new file mode 100644
index 000000000..0afd56b27
--- /dev/null
+++ b/src/contrib/service/consensus/consensus_protocol.h
@@ -0,0 +1,137 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2012 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+
+/**
+ * @file consensus/consensus_protocol.h
+ * @brief p2p message definitions for consensus
+ * @author Florian Dold
+ */
+
+#ifndef GNUNET_CONSENSUS_PROTOCOL_H
+#define GNUNET_CONSENSUS_PROTOCOL_H
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_common.h"
+#include "gnunet_protocols.h"
+
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * Sent as context message for set reconciliation.
+ *
+ * Essentially contains all the fields
+ * from 'struct TaskKey', but in NBO.
+ */
+struct GNUNET_CONSENSUS_RoundContextMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_ROUND_CONTEXT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * A value from 'enum PhaseKind'.
+   */
+  uint16_t kind GNUNET_PACKED;
+
+  /**
+   * Number of the first peer
+   * in canonical order.
+   */
+  int16_t peer1 GNUNET_PACKED;
+
+  /**
+   * Number of the second peer in canonical order.
+   */
+  int16_t peer2 GNUNET_PACKED;
+
+  /**
+   * Repetition of the gradecast phase.
+   */
+  int16_t repetition GNUNET_PACKED;
+
+  /**
+   * Leader in the gradecast phase.
+   *
+   * Can be different from both peer1 and peer2.
+   */
+  int16_t leader GNUNET_PACKED;
+
+  /**
+   * Non-zero if this set reconciliation
+   * had elements removed because they were contested.
+   *
+   * Will be considered when grading broadcasts.
+   *
+   * Ignored for set operations that are not within gradecasts.
+   */
+  uint16_t is_contested GNUNET_PACKED;
+};
+
+
+enum
+{
+  CONSENSUS_MARKER_CONTESTED = 1,
+  CONSENSUS_MARKER_SIZE = 2,
+};
+
+
+/**
+ * Consensus element, either marker or payload.
+ */
+struct ConsensusElement
+{
+  /**
+   * Payload element_type, only valid
+   * if this is not a marker element.
+   */
+  uint16_t payload_type GNUNET_PACKED;
+
+  /**
+   * Is this a marker element?
+   */
+  uint8_t marker;
+
+  /* rest: element data */
+};
+
+
+struct ConsensusSizeElement
+{
+  struct ConsensusElement ce;
+
+  uint64_t size GNUNET_PACKED;
+  uint8_t sender_index;
+};
+
+
+struct ConsensusStuffedElement
+{
+  struct ConsensusElement ce;
+  struct GNUNET_HashCode rand GNUNET_PACKED;
+};
+
+
+GNUNET_NETWORK_STRUCT_END
+
+#endif
diff --git a/src/contrib/service/consensus/gnunet-service-consensus.c b/src/contrib/service/consensus/gnunet-service-consensus.c
new file mode 100644
index 000000000..5b6b9bbd7
--- /dev/null
+++ b/src/contrib/service/consensus/gnunet-service-consensus.c
@@ -0,0 +1,3572 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2012, 2013, 2017, 2020 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 consensus/gnunet-service-consensus.c
+ * @brief multi-peer set reconciliation
+ * @author Florian Dold <flo@dold.me>
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_block_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_applications.h"
+#include "gnunet_set_service.h"
+#include "gnunet_statistics_service.h"
+#include "gnunet_consensus_service.h"
+#include "consensus_protocol.h"
+#include "consensus.h"
+
+
+enum ReferendumVote
+{
+  /**
+   * Vote that nothing should change.
+   * This option is never voted explicitly.
+   */
+  VOTE_STAY = 0,
+  /**
+   * Vote that an element should be added.
+   */
+  VOTE_ADD = 1,
+  /**
+   * Vote that an element should be removed.
+   */
+  VOTE_REMOVE = 2,
+};
+
+
+enum EarlyStoppingPhase
+{
+  EARLY_STOPPING_NONE = 0,
+  EARLY_STOPPING_ONE_MORE = 1,
+  EARLY_STOPPING_DONE = 2,
+};
+
+
+enum PhaseKind
+{
+  PHASE_KIND_ALL_TO_ALL,
+  PHASE_KIND_ALL_TO_ALL_2,
+  PHASE_KIND_GRADECAST_LEADER,
+  PHASE_KIND_GRADECAST_ECHO,
+  PHASE_KIND_GRADECAST_ECHO_GRADE,
+  PHASE_KIND_GRADECAST_CONFIRM,
+  PHASE_KIND_GRADECAST_CONFIRM_GRADE,
+  /**
+   * Apply a repetition of the all-to-all
+   * gradecast to the current set.
+   */
+  PHASE_KIND_APPLY_REP,
+  PHASE_KIND_FINISH,
+};
+
+
+enum SetKind
+{
+  SET_KIND_NONE = 0,
+  SET_KIND_CURRENT,
+  /**
+   * Last result set from a gradecast
+   */
+  SET_KIND_LAST_GRADECAST,
+  SET_KIND_LEADER_PROPOSAL,
+  SET_KIND_ECHO_RESULT,
+};
+
+enum DiffKind
+{
+  DIFF_KIND_NONE = 0,
+  DIFF_KIND_LEADER_PROPOSAL,
+  DIFF_KIND_LEADER_CONSENSUS,
+  DIFF_KIND_GRADECAST_RESULT,
+};
+
+enum RfnKind
+{
+  RFN_KIND_NONE = 0,
+  RFN_KIND_ECHO,
+  RFN_KIND_CONFIRM,
+  RFN_KIND_GRADECAST_RESULT
+};
+
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * Tuple of integers that together identify a task uniquely.
+ */
+struct TaskKey
+{
+  /**
+   * A value from 'enum PhaseKind'.
+   */
+  uint16_t kind GNUNET_PACKED;
+
+  /**
+   * Number of the first peer
+   * in canonical order.
+   */
+  int16_t peer1 GNUNET_PACKED;
+
+  /**
+   * Number of the second peer in canonical order.
+   */
+  int16_t peer2 GNUNET_PACKED;
+
+  /**
+   * Repetition of the gradecast phase.
+   */
+  int16_t repetition GNUNET_PACKED;
+
+  /**
+   * Leader in the gradecast phase.
+   *
+   * Can be different from both peer1 and peer2.
+   */
+  int16_t leader GNUNET_PACKED;
+};
+
+
+struct SetKey
+{
+  enum SetKind set_kind GNUNET_PACKED;
+  /**
+   * Repetition counter.
+   */
+  int k1 GNUNET_PACKED;
+  /**
+   * Leader (or 0).
+   */
+  int k2 GNUNET_PACKED;
+};
+
+
+struct SetEntry
+{
+  struct SetKey key;
+  struct GNUNET_SET_Handle *h;
+
+  /**
+   * #GNUNET_YES if the set resulted from applying a referendum with contested
+   * elements.
+   */
+  int is_contested;
+};
+
+
+struct DiffKey
+{
+  enum DiffKind diff_kind GNUNET_PACKED;
+
+  int k1 GNUNET_PACKED;
+
+  int k2 GNUNET_PACKED;
+};
+
+struct RfnKey
+{
+  enum RfnKind rfn_kind GNUNET_PACKED;
+  int k1 GNUNET_PACKED;
+  int k2 GNUNET_PACKED;
+};
+
+
+GNUNET_NETWORK_STRUCT_END
+
+
+struct SetOpCls
+{
+  struct SetKey input_set;
+
+  struct SetKey output_set;
+  struct RfnKey output_rfn;
+  struct DiffKey output_diff;
+
+  int do_not_remove;
+
+  int transceive_contested;
+
+  struct GNUNET_SET_OperationHandle *op;
+};
+
+
+struct FinishCls
+{
+  struct SetKey input_set;
+};
+
+/**
+ * Closure for both @a start_task
+ * and @a cancel_task.
+ */
+union TaskFuncCls
+{
+  struct SetOpCls setop;
+  struct FinishCls finish;
+};
+
+
+struct TaskEntry;
+
+
+typedef void
+(*TaskFunc) (struct TaskEntry *task);
+
+
+/*
+ * Node in the consensus task graph.
+ */
+struct TaskEntry
+{
+  struct TaskKey key;
+
+  struct Step *step;
+
+  int is_started;
+
+  int is_finished;
+
+  TaskFunc start;
+  TaskFunc cancel;
+
+  union TaskFuncCls cls;
+};
+
+
+struct Step
+{
+  /**
+   * All steps of one session are in a
+   * linked list for easier deallocation.
+   */
+  struct Step *prev;
+
+  /**
+   * All steps of one session are in a
+   * linked list for easier deallocation.
+   */
+  struct Step *next;
+
+  struct ConsensusSession *session;
+
+  /**
+   * Tasks that this step is composed of.
+   */
+  struct TaskEntry **tasks;
+  unsigned int tasks_len;
+  unsigned int tasks_cap;
+
+  unsigned int finished_tasks;
+
+  /*
+   * Tasks that have this task as dependency.
+   *
+   * We store pointers to subordinates rather
+   * than to prerequisites since it makes
+   * tracking the readiness of a task easier.
+   */
+  struct Step **subordinates;
+  unsigned int subordinates_len;
+  unsigned int subordinates_cap;
+
+  /**
+   * Counter for the prerequisites of this step.
+   */
+  size_t pending_prereq;
+
+  /**
+   * Task that will run this step despite any pending prerequisites.
+   */
+  struct GNUNET_SCHEDULER_Task *timeout_task;
+
+  unsigned int is_running;
+
+  unsigned int is_finished;
+
+  /**
+   * Synchrony round of the task.  Determines the deadline for the task.
+   */
+  unsigned int round;
+
+  /**
+   * Human-readable name for the task, used for debugging.
+   */
+  char *debug_name;
+
+  /**
+   * When we're doing an early finish, how should this step be treated?  If
+   * #GNUNET_YES, the step will be marked as finished without actually running
+   * its tasks.  Otherwise, the step will still be run even after an early
+   * finish.
+   *
+   * Note that a task may never be finished early if it is already running.
+   */
+  int early_finishable;
+};
+
+
+struct RfnElementInfo
+{
+  const struct GNUNET_SET_Element *element;
+
+  /**
+   * #GNUNET_YES if the peer votes for the proposal.
+   */
+  int *votes;
+
+  /**
+   * Proposal for this element, can only be #VOTE_ADD or #VOTE_REMOVE.
+   */
+  enum ReferendumVote proposal;
+};
+
+
+struct ReferendumEntry
+{
+  struct RfnKey key;
+
+  /*
+   * Elements where there is at least one proposed change.
+   *
+   * Maps the hash of the GNUNET_SET_Element
+   * to 'struct RfnElementInfo'.
+   */
+  struct GNUNET_CONTAINER_MultiHashMap *rfn_elements;
+
+  unsigned int num_peers;
+
+  /**
+   * Stores, for every peer in the session,
+   * whether the peer finished the whole referendum.
+   *
+   * Votes from peers are only counted if they're
+   * marked as committed (#GNUNET_YES) in the referendum.
+   *
+   * Otherwise (#GNUNET_NO), the requested changes are
+   * not counted for majority votes or thresholds.
+   */
+  int *peer_commited;
+
+
+  /**
+   * Contestation state of the peer.  If a peer is contested, the values it
+   * contributed are still counted for applying changes, but the grading is
+   * affected.
+   */
+  int *peer_contested;
+};
+
+
+struct DiffElementInfo
+{
+  const struct GNUNET_SET_Element *element;
+
+  /**
+   * Positive weight for 'add', negative
+   * weights for 'remove'.
+   */
+  int weight;
+};
+
+
+/**
+ * Weighted diff.
+ */
+struct DiffEntry
+{
+  struct DiffKey key;
+  struct GNUNET_CONTAINER_MultiHashMap *changes;
+};
+
+struct SetHandle
+{
+  struct SetHandle *prev;
+  struct SetHandle *next;
+
+  struct GNUNET_SET_Handle *h;
+};
+
+
+/**
+ * A consensus session consists of one local client and the remote authorities.
+ */
+struct ConsensusSession
+{
+  /**
+   * Consensus sessions are kept in a DLL.
+   */
+  struct ConsensusSession *next;
+
+  /**
+   * Consensus sessions are kept in a DLL.
+   */
+  struct ConsensusSession *prev;
+
+  unsigned int num_client_insert_pending;
+
+  struct GNUNET_CONTAINER_MultiHashMap *setmap;
+  struct GNUNET_CONTAINER_MultiHashMap *rfnmap;
+  struct GNUNET_CONTAINER_MultiHashMap *diffmap;
+
+  /**
+   * Array of peers with length 'num_peers'.
+   */
+  int *peers_blacklisted;
+
+  /*
+   * Mapping from (hashed) TaskKey to TaskEntry.
+   *
+   * We map the application_id for a round to the task that should be
+   * executed, so we don't have to go through all task whenever we get
+   * an incoming set op request.
+   */
+  struct GNUNET_CONTAINER_MultiHashMap *taskmap;
+
+  struct Step *steps_head;
+  struct Step *steps_tail;
+
+  int conclude_started;
+
+  int conclude_done;
+
+  /**
+   * Global consensus identification, computed
+   * from the session id and participating authorities.
+   */
+  struct GNUNET_HashCode global_id;
+
+  /**
+   * Client that inhabits the session
+   */
+  struct GNUNET_SERVICE_Client *client;
+
+  /**
+   * Queued messages to the client.
+   */
+  struct GNUNET_MQ_Handle *client_mq;
+
+  /**
+   * Time when the conclusion of the consensus should begin.
+   */
+  struct GNUNET_TIME_Absolute conclude_start;
+
+  /**
+   * Timeout for all rounds together, single rounds will schedule a timeout task
+   * with a fraction of the conclude timeout.
+   * Only valid once the current round is not CONSENSUS_ROUND_BEGIN.
+   */
+  struct GNUNET_TIME_Absolute conclude_deadline;
+
+  struct GNUNET_PeerIdentity *peers;
+
+  /**
+   * Number of other peers in the consensus.
+   */
+  unsigned int num_peers;
+
+  /**
+   * Index of the local peer in the peers array
+   */
+  unsigned int local_peer_idx;
+
+  /**
+   * Listener for requests from other peers.
+   * Uses the session's global id as app id.
+   */
+  struct GNUNET_SET_ListenHandle *set_listener;
+
+  /**
+   * State of our early stopping scheme.
+   */
+  int early_stopping;
+
+  /**
+   * Our set size from the first round.
+   */
+  uint64_t first_size;
+
+  uint64_t *first_sizes_received;
+
+  /**
+   * Bounded Eppstein lower bound.
+   */
+  uint64_t lower_bound;
+
+  struct SetHandle *set_handles_head;
+  struct SetHandle *set_handles_tail;
+};
+
+/**
+ * Linked list of sessions this peer participates in.
+ */
+static struct ConsensusSession *sessions_head;
+
+/**
+ * Linked list of sessions this peer participates in.
+ */
+static struct ConsensusSession *sessions_tail;
+
+/**
+ * Configuration of the consensus service.
+ */
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Peer that runs this service.
+ */
+static struct GNUNET_PeerIdentity my_peer;
+
+/**
+ * Statistics handle.
+ */
+struct GNUNET_STATISTICS_Handle *statistics;
+
+
+static void
+finish_task (struct TaskEntry *task);
+
+
+static void
+run_ready_steps (struct ConsensusSession *session);
+
+
+static const char *
+phasename (uint16_t phase)
+{
+  switch (phase)
+  {
+  case PHASE_KIND_ALL_TO_ALL: return "ALL_TO_ALL";
+
+  case PHASE_KIND_ALL_TO_ALL_2: return "ALL_TO_ALL_2";
+
+  case PHASE_KIND_FINISH: return "FINISH";
+
+  case PHASE_KIND_GRADECAST_LEADER: return "GRADECAST_LEADER";
+
+  case PHASE_KIND_GRADECAST_ECHO: return "GRADECAST_ECHO";
+
+  case PHASE_KIND_GRADECAST_ECHO_GRADE: return "GRADECAST_ECHO_GRADE";
+
+  case PHASE_KIND_GRADECAST_CONFIRM: return "GRADECAST_CONFIRM";
+
+  case PHASE_KIND_GRADECAST_CONFIRM_GRADE: return "GRADECAST_CONFIRM_GRADE";
+
+  case PHASE_KIND_APPLY_REP: return "APPLY_REP";
+
+  default: return "(unknown)";
+  }
+}
+
+
+static const char *
+setname (uint16_t kind)
+{
+  switch (kind)
+  {
+  case SET_KIND_CURRENT: return "CURRENT";
+
+  case SET_KIND_LEADER_PROPOSAL: return "LEADER_PROPOSAL";
+
+  case SET_KIND_NONE: return "NONE";
+
+  default: return "(unknown)";
+  }
+}
+
+
+static const char *
+rfnname (uint16_t kind)
+{
+  switch (kind)
+  {
+  case RFN_KIND_NONE: return "NONE";
+
+  case RFN_KIND_ECHO: return "ECHO";
+
+  case RFN_KIND_CONFIRM: return "CONFIRM";
+
+  default: return "(unknown)";
+  }
+}
+
+
+static const char *
+diffname (uint16_t kind)
+{
+  switch (kind)
+  {
+  case DIFF_KIND_NONE: return "NONE";
+
+  case DIFF_KIND_LEADER_CONSENSUS: return "LEADER_CONSENSUS";
+
+  case DIFF_KIND_GRADECAST_RESULT: return "GRADECAST_RESULT";
+
+  case DIFF_KIND_LEADER_PROPOSAL: return "LEADER_PROPOSAL";
+
+  default: return "(unknown)";
+  }
+}
+
+
+#ifdef GNUNET_EXTRA_LOGGING
+
+
+static const char *
+debug_str_element (const struct GNUNET_SET_Element *el)
+{
+  struct GNUNET_HashCode hash;
+
+  GNUNET_SET_element_hash (el, &hash);
+
+  return GNUNET_h2s (&hash);
+}
+
+
+static const char *
+debug_str_task_key (const struct TaskKey *tk)
+{
+  static char buf[256];
+
+  snprintf (buf, sizeof(buf),
+            "TaskKey kind=%s, p1=%d, p2=%d, l=%d, rep=%d",
+            phasename (tk->kind), tk->peer1, tk->peer2,
+            tk->leader, tk->repetition);
+
+  return buf;
+}
+
+
+static const char *
+debug_str_diff_key (const struct DiffKey *dk)
+{
+  static char buf[256];
+
+  snprintf (buf, sizeof(buf),
+            "DiffKey kind=%s, k1=%d, k2=%d",
+            diffname (dk->diff_kind), dk->k1, dk->k2);
+
+  return buf;
+}
+
+
+static const char *
+debug_str_set_key (const struct SetKey *sk)
+{
+  static char buf[256];
+
+  snprintf (buf, sizeof(buf),
+            "SetKey kind=%s, k1=%d, k2=%d",
+            setname (sk->set_kind),
+            sk->k1,
+            sk->k2);
+  return buf;
+}
+
+
+static const char *
+debug_str_rfn_key (const struct RfnKey *rk)
+{
+  static char buf[256];
+
+  snprintf (buf, sizeof(buf),
+            "RfnKey kind=%s, k1=%d, k2=%d",
+            rfnname (rk->rfn_kind),
+            rk->k1,
+            rk->k2);
+  return buf;
+}
+
+
+#endif /* GNUNET_EXTRA_LOGGING */
+
+
+/**
+ * Send the final result set of the consensus to the client, element by
+ * element.
+ *
+ * @param cls closure
+ * @param element the current element, NULL if all elements have been
+ *        iterated over
+ * @return #GNUNET_YES to continue iterating, #GNUNET_NO to stop.
+ */
+static int
+send_to_client_iter (void *cls,
+                     const struct GNUNET_SET_Element *element)
+{
+  struct TaskEntry *task = (struct TaskEntry *) cls;
+  struct ConsensusSession *session = task->step->session;
+  struct GNUNET_MQ_Envelope *ev;
+
+  if (NULL != element)
+  {
+    struct GNUNET_CONSENSUS_ElementMessage *m;
+    const struct ConsensusElement *ce;
+
+    GNUNET_assert (GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT ==
+                   element->element_type);
+    ce = element->data;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "marker is %u\n",
+                (unsigned) ce->marker);
+
+    if (0 != ce->marker)
+      return GNUNET_YES;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%d: sending element %s to client\n",
+                session->local_peer_idx,
+                debug_str_element (element));
+
+    ev = GNUNET_MQ_msg_extra (m,
+                              element->size - sizeof(struct ConsensusElement),
+                              GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_RECEIVED_ELEMENT);
+    m->element_type = ce->payload_type;
+    GNUNET_memcpy (&m[1],
+                   &ce[1],
+                   element->size - sizeof(struct ConsensusElement));
+    GNUNET_MQ_send (session->client_mq,
+                    ev);
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%d: finished iterating elements for client\n",
+                session->local_peer_idx);
+    ev = GNUNET_MQ_msg_header (
+      GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE_DONE);
+    GNUNET_MQ_send (session->client_mq,
+                    ev);
+  }
+  return GNUNET_YES;
+}
+
+
+static struct SetEntry *
+lookup_set (struct ConsensusSession *session,
+            const struct SetKey *key)
+{
+  struct GNUNET_HashCode hash;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "P%u: looking up set {%s}\n",
+              session->local_peer_idx,
+              debug_str_set_key (key));
+
+  GNUNET_assert (SET_KIND_NONE != key->set_kind);
+  GNUNET_CRYPTO_hash (key,
+                      sizeof(struct SetKey),
+                      &hash);
+  return GNUNET_CONTAINER_multihashmap_get (session->setmap,
+                                            &hash);
+}
+
+
+static struct DiffEntry *
+lookup_diff (struct ConsensusSession *session,
+             const struct DiffKey *key)
+{
+  struct GNUNET_HashCode hash;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "P%u: looking up diff {%s}\n",
+              session->local_peer_idx,
+              debug_str_diff_key (key));
+  GNUNET_assert (DIFF_KIND_NONE != key->diff_kind);
+  GNUNET_CRYPTO_hash (key,
+                      sizeof(struct DiffKey),
+                      &hash);
+  return GNUNET_CONTAINER_multihashmap_get (session->diffmap,
+                                            &hash);
+}
+
+
+static struct ReferendumEntry *
+lookup_rfn (struct ConsensusSession *session,
+            const struct RfnKey *key)
+{
+  struct GNUNET_HashCode hash;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "P%u: looking up rfn {%s}\n",
+              session->local_peer_idx,
+              debug_str_rfn_key (key));
+  GNUNET_assert (RFN_KIND_NONE != key->rfn_kind);
+  GNUNET_CRYPTO_hash (key,
+                      sizeof(struct RfnKey),
+                      &hash);
+  return GNUNET_CONTAINER_multihashmap_get (session->rfnmap,
+                                            &hash);
+}
+
+
+static void
+diff_insert (struct DiffEntry *diff,
+             int weight,
+             const struct GNUNET_SET_Element *element)
+{
+  struct DiffElementInfo *di;
+  struct GNUNET_HashCode hash;
+
+  GNUNET_assert ((1 == weight) || (-1 == weight));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "diff_insert with element size %u\n",
+              element->size);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "hashing element\n");
+
+  GNUNET_SET_element_hash (element, &hash);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "hashed element\n");
+
+  di = GNUNET_CONTAINER_multihashmap_get (diff->changes, &hash);
+
+  if (NULL == di)
+  {
+    di = GNUNET_new (struct DiffElementInfo);
+    di->element = GNUNET_SET_element_dup (element);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multihashmap_put (diff->changes,
+                                                      &hash,
+                                                      di,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
+  }
+
+  di->weight = weight;
+}
+
+
+static void
+rfn_commit (struct ReferendumEntry *rfn,
+            uint16_t commit_peer)
+{
+  GNUNET_assert (commit_peer < rfn->num_peers);
+
+  rfn->peer_commited[commit_peer] = GNUNET_YES;
+}
+
+
+static void
+rfn_contest (struct ReferendumEntry *rfn,
+             uint16_t contested_peer)
+{
+  GNUNET_assert (contested_peer < rfn->num_peers);
+
+  rfn->peer_contested[contested_peer] = GNUNET_YES;
+}
+
+
+static uint16_t
+rfn_noncontested (struct ReferendumEntry *rfn)
+{
+  uint16_t ret;
+
+  ret = 0;
+  for (uint16_t i = 0; i < rfn->num_peers; i++)
+    if ((GNUNET_YES == rfn->peer_commited[i]) && (GNUNET_NO ==
+                                                  rfn->peer_contested[i]))
+      ret++;
+
+  return ret;
+}
+
+
+static void
+rfn_vote (struct ReferendumEntry *rfn,
+          uint16_t voting_peer,
+          enum ReferendumVote vote,
+          const struct GNUNET_SET_Element *element)
+{
+  struct RfnElementInfo *ri;
+  struct GNUNET_HashCode hash;
+
+  GNUNET_assert (voting_peer < rfn->num_peers);
+
+  /* Explicit voting only makes sense with VOTE_ADD or VOTE_REMOTE,
+     since VOTE_KEEP is implicit in not voting. */
+  GNUNET_assert ((VOTE_ADD == vote) || (VOTE_REMOVE == vote));
+
+  GNUNET_SET_element_hash (element, &hash);
+  ri = GNUNET_CONTAINER_multihashmap_get (rfn->rfn_elements, &hash);
+
+  if (NULL == ri)
+  {
+    ri = GNUNET_new (struct RfnElementInfo);
+    ri->element = GNUNET_SET_element_dup (element);
+    ri->votes = GNUNET_new_array (rfn->num_peers, int);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multihashmap_put (rfn->rfn_elements,
+                                                      &hash, ri,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
+  }
+
+  ri->votes[voting_peer] = GNUNET_YES;
+  ri->proposal = vote;
+}
+
+
+static uint16_t
+task_other_peer (struct TaskEntry *task)
+{
+  uint16_t me = task->step->session->local_peer_idx;
+
+  if (task->key.peer1 == me)
+    return task->key.peer2;
+  return task->key.peer1;
+}
+
+
+static int
+cmp_uint64_t (const void *pa, const void *pb)
+{
+  uint64_t a = *(uint64_t *) pa;
+  uint64_t b = *(uint64_t *) pb;
+
+  if (a == b)
+    return 0;
+  if (a < b)
+    return -1;
+  return 1;
+}
+
+
+/**
+ * Callback for set operation results. Called for each element
+ * in the result set.
+ *
+ * @param cls closure
+ * @param element a result element, only valid if status is #GNUNET_SET_STATUS_OK
+ * @param current_size current set size
+ * @param status see enum GNUNET_SET_Status
+ */
+static void
+set_result_cb (void *cls,
+               const struct GNUNET_SET_Element *element,
+               uint64_t current_size,
+               enum GNUNET_SET_Status status)
+{
+  struct TaskEntry *task = cls;
+  struct ConsensusSession *session = task->step->session;
+  struct SetEntry *output_set = NULL;
+  struct DiffEntry *output_diff = NULL;
+  struct ReferendumEntry *output_rfn = NULL;
+  unsigned int other_idx;
+  struct SetOpCls *setop;
+  const struct ConsensusElement *consensus_element = NULL;
+
+  if (NULL != element)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%u: got element of type %u, status %u\n",
+                session->local_peer_idx,
+                (unsigned) element->element_type,
+                (unsigned) status);
+    GNUNET_assert (GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT ==
+                   element->element_type);
+    consensus_element = element->data;
+  }
+
+  setop = &task->cls.setop;
+
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "P%u: got set result for {%s}, status %u\n",
+              session->local_peer_idx,
+              debug_str_task_key (&task->key),
+              status);
+
+  if (GNUNET_NO == task->is_started)
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+
+  if (GNUNET_YES == task->is_finished)
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+
+  other_idx = task_other_peer (task);
+
+  if (SET_KIND_NONE != setop->output_set.set_kind)
+  {
+    output_set = lookup_set (session,
+                             &setop->output_set);
+    GNUNET_assert (NULL != output_set);
+  }
+
+  if (DIFF_KIND_NONE != setop->output_diff.diff_kind)
+  {
+    output_diff = lookup_diff (session, &setop->output_diff);
+    GNUNET_assert (NULL != output_diff);
+  }
+
+  if (RFN_KIND_NONE != setop->output_rfn.rfn_kind)
+  {
+    output_rfn = lookup_rfn (session, &setop->output_rfn);
+    GNUNET_assert (NULL != output_rfn);
+  }
+
+  if (GNUNET_YES == session->peers_blacklisted[other_idx])
+  {
+    /* Peer might have been blacklisted
+       by a gradecast running in parallel, ignore elements from now */
+    if (GNUNET_SET_STATUS_ADD_LOCAL == status)
+      return;
+    if (GNUNET_SET_STATUS_ADD_REMOTE == status)
+      return;
+  }
+
+  if ((NULL != consensus_element) && (0 != consensus_element->marker))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%u: got some marker\n",
+                session->local_peer_idx);
+    if ((GNUNET_YES == setop->transceive_contested) &&
+        (CONSENSUS_MARKER_CONTESTED == consensus_element->marker))
+    {
+      GNUNET_assert (NULL != output_rfn);
+      rfn_contest (output_rfn, task_other_peer (task));
+      return;
+    }
+
+    if (CONSENSUS_MARKER_SIZE == consensus_element->marker)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: got size marker\n",
+                  session->local_peer_idx);
+
+
+      struct ConsensusSizeElement *cse = (void *) consensus_element;
+
+      if (cse->sender_index == other_idx)
+      {
+        if (NULL == session->first_sizes_received)
+          session->first_sizes_received = GNUNET_new_array (session->num_peers,
+                                                            uint64_t);
+        session->first_sizes_received[other_idx] = GNUNET_ntohll (cse->size);
+
+        uint64_t *copy = GNUNET_memdup (session->first_sizes_received,
+                                        sizeof(uint64_t) * session->num_peers);
+        qsort (copy, session->num_peers, sizeof(uint64_t), cmp_uint64_t);
+        session->lower_bound = copy[session->num_peers / 3 + 1];
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "P%u: lower bound %llu\n",
+                    session->local_peer_idx,
+                    (long long) session->lower_bound);
+        GNUNET_free (copy);
+      }
+      return;
+    }
+
+    return;
+  }
+
+  switch (status)
+  {
+  case GNUNET_SET_STATUS_ADD_LOCAL:
+    GNUNET_assert (NULL != consensus_element);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Adding element in Task {%s}\n",
+                debug_str_task_key (&task->key));
+    if (NULL != output_set)
+    {
+      // FIXME: record pending adds, use callback
+      GNUNET_SET_add_element (output_set->h,
+                              element,
+                              NULL,
+                              NULL);
+#ifdef GNUNET_EXTRA_LOGGING
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: adding element %s into set {%s} of task {%s}\n",
+                  session->local_peer_idx,
+                  debug_str_element (element),
+                  debug_str_set_key (&setop->output_set),
+                  debug_str_task_key (&task->key));
+#endif
+    }
+    if (NULL != output_diff)
+    {
+      diff_insert (output_diff, 1, element);
+#ifdef GNUNET_EXTRA_LOGGING
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: adding element %s into diff {%s} of task {%s}\n",
+                  session->local_peer_idx,
+                  debug_str_element (element),
+                  debug_str_diff_key (&setop->output_diff),
+                  debug_str_task_key (&task->key));
+#endif
+    }
+    if (NULL != output_rfn)
+    {
+      rfn_vote (output_rfn, task_other_peer (task), VOTE_ADD, element);
+#ifdef GNUNET_EXTRA_LOGGING
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: adding element %s into rfn {%s} of task {%s}\n",
+                  session->local_peer_idx,
+                  debug_str_element (element),
+                  debug_str_rfn_key (&setop->output_rfn),
+                  debug_str_task_key (&task->key));
+#endif
+    }
+    // XXX: add result to structures in task
+    break;
+
+  case GNUNET_SET_STATUS_ADD_REMOTE:
+    GNUNET_assert (NULL != consensus_element);
+    if (GNUNET_YES == setop->do_not_remove)
+      break;
+    if (CONSENSUS_MARKER_CONTESTED == consensus_element->marker)
+      break;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Removing element in Task {%s}\n",
+                debug_str_task_key (&task->key));
+    if (NULL != output_set)
+    {
+      // FIXME: record pending adds, use callback
+      GNUNET_SET_remove_element (output_set->h,
+                                 element,
+                                 NULL,
+                                 NULL);
+#ifdef GNUNET_EXTRA_LOGGING
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: removing element %s from set {%s} of task {%s}\n",
+                  session->local_peer_idx,
+                  debug_str_element (element),
+                  debug_str_set_key (&setop->output_set),
+                  debug_str_task_key (&task->key));
+#endif
+    }
+    if (NULL != output_diff)
+    {
+      diff_insert (output_diff, -1, element);
+#ifdef GNUNET_EXTRA_LOGGING
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: removing element %s from diff {%s} of task {%s}\n",
+                  session->local_peer_idx,
+                  debug_str_element (element),
+                  debug_str_diff_key (&setop->output_diff),
+                  debug_str_task_key (&task->key));
+#endif
+    }
+    if (NULL != output_rfn)
+    {
+      rfn_vote (output_rfn, task_other_peer (task), VOTE_REMOVE, element);
+#ifdef GNUNET_EXTRA_LOGGING
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: removing element %s from rfn {%s} of task {%s}\n",
+                  session->local_peer_idx,
+                  debug_str_element (element),
+                  debug_str_rfn_key (&setop->output_rfn),
+                  debug_str_task_key (&task->key));
+#endif
+    }
+    break;
+
+  case GNUNET_SET_STATUS_DONE:
+    // XXX: check first if any changes to the underlying
+    // set are still pending
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%u: Finishing setop in Task {%s} (%u/%u)\n",
+                session->local_peer_idx,
+                debug_str_task_key (&task->key),
+                (unsigned int) task->step->finished_tasks,
+                (unsigned int) task->step->tasks_len);
+    if (NULL != output_rfn)
+    {
+      rfn_commit (output_rfn, task_other_peer (task));
+    }
+    if (PHASE_KIND_ALL_TO_ALL == task->key.kind)
+    {
+      session->first_size = current_size;
+    }
+    finish_task (task);
+    break;
+
+  case GNUNET_SET_STATUS_FAILURE:
+    // XXX: cleanup
+    GNUNET_break_op (0);
+    finish_task (task);
+    return;
+
+  default:
+    /* not reached */
+    GNUNET_assert (0);
+  }
+}
+
+
+#ifdef EVIL
+
+enum EvilnessType
+{
+  EVILNESS_NONE,
+  EVILNESS_CRAM_ALL,
+  EVILNESS_CRAM_LEAD,
+  EVILNESS_CRAM_ECHO,
+  EVILNESS_SLACK,
+  EVILNESS_SLACK_A2A,
+};
+
+enum EvilnessSubType
+{
+  EVILNESS_SUB_NONE,
+  EVILNESS_SUB_REPLACEMENT,
+  EVILNESS_SUB_NO_REPLACEMENT,
+};
+
+struct Evilness
+{
+  enum EvilnessType type;
+  enum EvilnessSubType subtype;
+  unsigned int num;
+};
+
+
+static int
+parse_evilness_cram_subtype (const char *evil_subtype_str,
+                             struct Evilness *evil)
+{
+  if (0 == strcmp ("replace", evil_subtype_str))
+  {
+    evil->subtype = EVILNESS_SUB_REPLACEMENT;
+  }
+  else if (0 == strcmp ("noreplace", evil_subtype_str))
+  {
+    evil->subtype = EVILNESS_SUB_NO_REPLACEMENT;
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Malformed field '%s' in EVIL_SPEC (unknown subtype), behaving like a good peer.\n",
+                evil_subtype_str);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+static void
+get_evilness (struct ConsensusSession *session, struct Evilness *evil)
+{
+  char *evil_spec;
+  char *field;
+  char *evil_type_str = NULL;
+  char *evil_subtype_str = NULL;
+
+  GNUNET_assert (NULL != evil);
+
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "consensus",
+                                                          "EVIL_SPEC",
+                                                          &evil_spec))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%u: no evilness\n",
+                session->local_peer_idx);
+    evil->type = EVILNESS_NONE;
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "P%u: got evilness spec\n",
+              session->local_peer_idx);
+
+  for (field = strtok (evil_spec, "/");
+       NULL != field;
+       field = strtok (NULL, "/"))
+  {
+    unsigned int peer_num;
+    unsigned int evil_num;
+    int ret;
+
+    evil_type_str = NULL;
+    evil_subtype_str = NULL;
+
+    ret = sscanf (field, "%u;%m[a-z-];%m[a-z-];%u", &peer_num, &evil_type_str,
+                  &evil_subtype_str, &evil_num);
+
+    if (ret != 4)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Malformed field '%s' in EVIL_SPEC (expected 4 components got %d), behaving like a good peer.\n",
+                  field,
+                  ret);
+      goto not_evil;
+    }
+
+    GNUNET_assert (NULL != evil_type_str);
+    GNUNET_assert (NULL != evil_subtype_str);
+
+    if (peer_num == session->local_peer_idx)
+    {
+      if (0 == strcmp ("slack", evil_type_str))
+      {
+        evil->type = EVILNESS_SLACK;
+      }
+      if (0 == strcmp ("slack-a2a", evil_type_str))
+      {
+        evil->type = EVILNESS_SLACK_A2A;
+      }
+      else if (0 == strcmp ("cram-all", evil_type_str))
+      {
+        evil->type = EVILNESS_CRAM_ALL;
+        evil->num = evil_num;
+        if (GNUNET_OK != parse_evilness_cram_subtype (evil_subtype_str, evil))
+          goto not_evil;
+      }
+      else if (0 == strcmp ("cram-lead", evil_type_str))
+      {
+        evil->type = EVILNESS_CRAM_LEAD;
+        evil->num = evil_num;
+        if (GNUNET_OK != parse_evilness_cram_subtype (evil_subtype_str, evil))
+          goto not_evil;
+      }
+      else if (0 == strcmp ("cram-echo", evil_type_str))
+      {
+        evil->type = EVILNESS_CRAM_ECHO;
+        evil->num = evil_num;
+        if (GNUNET_OK != parse_evilness_cram_subtype (evil_subtype_str, evil))
+          goto not_evil;
+      }
+      else
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "Malformed field '%s' in EVIL_SPEC (unknown type), behaving like a good peer.\n",
+                    evil_type_str);
+        goto not_evil;
+      }
+      goto cleanup;
+    }
+    /* No GNUNET_free since memory was allocated by libc */
+    free (evil_type_str);
+    evil_type_str = NULL;
+    evil_subtype_str = NULL;
+  }
+not_evil:
+  evil->type = EVILNESS_NONE;
+cleanup:
+  GNUNET_free (evil_spec);
+  /* no GNUNET_free since it wasn't
+   * allocated with GNUNET_malloc */
+  if (NULL != evil_type_str)
+    free (evil_type_str);
+  if (NULL != evil_subtype_str)
+    free (evil_subtype_str);
+}
+
+
+#endif
+
+
+/**
+ * Commit the appropriate set for a task.
+ */
+static void
+commit_set (struct ConsensusSession *session,
+            struct TaskEntry *task)
+{
+  struct SetEntry *set;
+  struct SetOpCls *setop = &task->cls.setop;
+
+  GNUNET_assert (NULL != setop->op);
+  set = lookup_set (session, &setop->input_set);
+  GNUNET_assert (NULL != set);
+
+  if ((GNUNET_YES == setop->transceive_contested) && (GNUNET_YES ==
+                                                      set->is_contested))
+  {
+    struct GNUNET_SET_Element element;
+    struct ConsensusElement ce = { 0 };
+
+    ce.marker = CONSENSUS_MARKER_CONTESTED;
+    element.data = &ce;
+    element.size = sizeof(struct ConsensusElement);
+    element.element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT;
+    GNUNET_SET_add_element (set->h, &element, NULL, NULL);
+  }
+
+  if (PHASE_KIND_ALL_TO_ALL_2 == task->key.kind)
+  {
+    struct GNUNET_SET_Element element;
+    struct ConsensusSizeElement cse = {
+      .size = 0,
+      .sender_index = 0
+    };
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "inserting size marker\n");
+    cse.ce.marker = CONSENSUS_MARKER_SIZE;
+    cse.size = GNUNET_htonll (session->first_size);
+    cse.sender_index = session->local_peer_idx;
+    element.data = &cse;
+    element.size = sizeof(struct ConsensusSizeElement);
+    element.element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT;
+    GNUNET_SET_add_element (set->h, &element, NULL, NULL);
+  }
+
+#ifdef EVIL
+  {
+    struct Evilness evil;
+
+    get_evilness (session, &evil);
+    if (EVILNESS_NONE != evil.type)
+    {
+      /* Useful for evaluation */
+      GNUNET_STATISTICS_set (statistics,
+                             "is evil",
+                             1,
+                             GNUNET_NO);
+    }
+    switch (evil.type)
+    {
+    case EVILNESS_CRAM_ALL:
+    case EVILNESS_CRAM_LEAD:
+    case EVILNESS_CRAM_ECHO:
+      /* We're not cramming elements in the
+         all-to-all round, since that would just
+         add more elements to the result set, but
+         wouldn't test robustness. */
+      if (PHASE_KIND_ALL_TO_ALL == task->key.kind)
+      {
+        GNUNET_SET_commit (setop->op, set->h);
+        break;
+      }
+      if ((EVILNESS_CRAM_LEAD == evil.type) &&
+          ((PHASE_KIND_GRADECAST_LEADER != task->key.kind) ||
+           (SET_KIND_CURRENT != set->key.set_kind) ))
+      {
+        GNUNET_SET_commit (setop->op, set->h);
+        break;
+      }
+      if ((EVILNESS_CRAM_ECHO == evil.type) && (PHASE_KIND_GRADECAST_ECHO !=
+                                                task->key.kind))
+      {
+        GNUNET_SET_commit (setop->op, set->h);
+        break;
+      }
+      for (unsigned int i = 0; i < evil.num; i++)
+      {
+        struct GNUNET_SET_Element element;
+        struct ConsensusStuffedElement se = {
+          .ce.payload_type = 0,
+          .ce.marker = 0,
+        };
+        element.data = &se;
+        element.size = sizeof(struct ConsensusStuffedElement);
+        element.element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT;
+
+        if (EVILNESS_SUB_REPLACEMENT == evil.subtype)
+        {
+          /* Always generate a new element. */
+          GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK,
+                                            &se.rand);
+        }
+        else if (EVILNESS_SUB_NO_REPLACEMENT == evil.subtype)
+        {
+          /* Always cram the same elements, derived from counter. */
+          GNUNET_CRYPTO_hash (&i, sizeof(i), &se.rand);
+        }
+        else
+        {
+          GNUNET_assert (0);
+        }
+        GNUNET_SET_add_element (set->h, &element, NULL, NULL);
+#ifdef GNUNET_EXTRA_LOGGING
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "P%u: evil peer: cramming element %s into set {%s} of task {%s}\n",
+                    session->local_peer_idx,
+                    debug_str_element (&element),
+                    debug_str_set_key (&setop->input_set),
+                    debug_str_task_key (&task->key));
+#endif
+      }
+      GNUNET_STATISTICS_update (statistics,
+                                "# stuffed elements",
+                                evil.num,
+                                GNUNET_NO);
+      GNUNET_SET_commit (setop->op, set->h);
+      break;
+
+    case EVILNESS_SLACK:
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: evil peer: slacking\n",
+                  (unsigned int) session->local_peer_idx);
+
+    /* Do nothing. */
+    case EVILNESS_SLACK_A2A:
+      if ((PHASE_KIND_ALL_TO_ALL_2 == task->key.kind) ||
+          (PHASE_KIND_ALL_TO_ALL == task->key.kind))
+      {
+        struct GNUNET_SET_Handle *empty_set;
+        empty_set = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION);
+        GNUNET_SET_commit (setop->op, empty_set);
+        GNUNET_SET_destroy (empty_set);
+      }
+      else
+      {
+        GNUNET_SET_commit (setop->op,
+                           set->h);
+      }
+      break;
+
+    case EVILNESS_NONE:
+      GNUNET_SET_commit (setop->op,
+                         set->h);
+      break;
+    }
+  }
+#else
+  if (GNUNET_NO == session->peers_blacklisted[task_other_peer (task)])
+  {
+    GNUNET_SET_commit (setop->op, set->h);
+  }
+  else
+  {
+    /* For our testcases, we don't want the blacklisted
+       peers to wait. */
+    GNUNET_SET_operation_cancel (setop->op);
+    setop->op = NULL;
+    finish_task (task);
+  }
+#endif
+}
+
+
+static void
+put_diff (struct ConsensusSession *session,
+          struct DiffEntry *diff)
+{
+  struct GNUNET_HashCode hash;
+
+  GNUNET_CRYPTO_hash (&diff->key,
+                      sizeof(struct DiffKey),
+                      &hash);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multihashmap_put (session->diffmap,
+                                                    &hash,
+                                                    diff,
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+}
+
+
+static void
+put_set (struct ConsensusSession *session,
+         struct SetEntry *set)
+{
+  struct GNUNET_HashCode hash;
+
+  GNUNET_assert (NULL != set->h);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Putting set %s\n",
+              debug_str_set_key (&set->key));
+  GNUNET_CRYPTO_hash (&set->key,
+                      sizeof(struct SetKey),
+                      &hash);
+  GNUNET_assert (GNUNET_SYSERR !=
+                 GNUNET_CONTAINER_multihashmap_put (session->setmap,
+                                                    &hash,
+                                                    set,
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
+}
+
+
+static void
+put_rfn (struct ConsensusSession *session,
+         struct ReferendumEntry *rfn)
+{
+  struct GNUNET_HashCode hash;
+
+  GNUNET_CRYPTO_hash (&rfn->key, sizeof(struct RfnKey), &hash);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multihashmap_put (session->rfnmap,
+                                                    &hash,
+                                                    rfn,
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+}
+
+
+static void
+task_cancel_reconcile (struct TaskEntry *task)
+{
+  /* not implemented yet */
+  GNUNET_assert (0);
+}
+
+
+static void
+apply_diff_to_rfn (struct DiffEntry *diff,
+                   struct ReferendumEntry *rfn,
+                   uint16_t voting_peer,
+                   uint16_t num_peers)
+{
+  struct GNUNET_CONTAINER_MultiHashMapIterator *iter;
+  struct DiffElementInfo *di;
+
+  iter = GNUNET_CONTAINER_multihashmap_iterator_create (diff->changes);
+
+  while (GNUNET_YES ==
+         GNUNET_CONTAINER_multihashmap_iterator_next (iter,
+                                                      NULL,
+                                                      (const void **) &di))
+  {
+    if (di->weight > 0)
+    {
+      rfn_vote (rfn, voting_peer, VOTE_ADD, di->element);
+    }
+    if (di->weight < 0)
+    {
+      rfn_vote (rfn, voting_peer, VOTE_REMOVE, di->element);
+    }
+  }
+
+  GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
+}
+
+
+static struct DiffEntry *
+diff_create (void)
+{
+  struct DiffEntry *d = GNUNET_new (struct DiffEntry);
+
+  d->changes = GNUNET_CONTAINER_multihashmap_create (8,
+                                                     GNUNET_NO);
+
+  return d;
+}
+
+
+#if 0
+static struct DiffEntry *
+diff_compose (struct DiffEntry *diff_1,
+              struct DiffEntry *diff_2)
+{
+  struct DiffEntry *diff_new;
+  struct GNUNET_CONTAINER_MultiHashMapIterator *iter;
+  struct DiffElementInfo *di;
+
+  diff_new = diff_create ();
+
+  iter = GNUNET_CONTAINER_multihashmap_iterator_create (diff_1->changes);
+  while (GNUNET_YES ==
+         GNUNET_CONTAINER_multihashmap_iterator_next (iter,
+                                                      NULL,
+                                                      (const void **) &di))
+  {
+    diff_insert (diff_new,
+                 di->weight,
+                 di->element);
+  }
+  GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
+
+  iter = GNUNET_CONTAINER_multihashmap_iterator_create (diff_2->changes);
+  while (GNUNET_YES ==
+         GNUNET_CONTAINER_multihashmap_iterator_next (iter,
+                                                      NULL,
+                                                      (const void **) &di))
+  {
+    diff_insert (diff_new,
+                 di->weight,
+                 di->element);
+  }
+  GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
+
+  return diff_new;
+}
+
+
+#endif
+
+
+struct ReferendumEntry *
+rfn_create (uint16_t size)
+{
+  struct ReferendumEntry *rfn;
+
+  rfn = GNUNET_new (struct ReferendumEntry);
+  rfn->rfn_elements = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
+  rfn->peer_commited = GNUNET_new_array (size, int);
+  rfn->peer_contested = GNUNET_new_array (size, int);
+  rfn->num_peers = size;
+
+  return rfn;
+}
+
+
+#if UNUSED
+static void
+diff_destroy (struct DiffEntry *diff)
+{
+  GNUNET_CONTAINER_multihashmap_destroy (diff->changes);
+  GNUNET_free (diff);
+}
+
+
+#endif
+
+
+/**
+ * For a given majority, count what the outcome
+ * is (add/remove/keep), and give the number
+ * of peers that voted for this outcome.
+ */
+static void
+rfn_majority (const struct ReferendumEntry *rfn,
+              const struct RfnElementInfo *ri,
+              uint16_t *ret_majority,
+              enum ReferendumVote *ret_vote)
+{
+  uint16_t votes_yes = 0;
+  uint16_t num_commited = 0;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Computing rfn majority for element %s of rfn {%s}\n",
+              debug_str_element (ri->element),
+              debug_str_rfn_key (&rfn->key));
+
+  for (uint16_t i = 0; i < rfn->num_peers; i++)
+  {
+    if (GNUNET_NO == rfn->peer_commited[i])
+      continue;
+    num_commited++;
+
+    if (GNUNET_YES == ri->votes[i])
+      votes_yes++;
+  }
+
+  if (votes_yes > (num_commited) / 2)
+  {
+    *ret_vote = ri->proposal;
+    *ret_majority = votes_yes;
+  }
+  else
+  {
+    *ret_vote = VOTE_STAY;
+    *ret_majority = num_commited - votes_yes;
+  }
+}
+
+
+struct SetCopyCls
+{
+  struct TaskEntry *task;
+  struct SetKey dst_set_key;
+};
+
+
+static void
+set_copy_cb (void *cls,
+             struct GNUNET_SET_Handle *copy)
+{
+  struct SetCopyCls *scc = cls;
+  struct TaskEntry *task = scc->task;
+  struct SetKey dst_set_key = scc->dst_set_key;
+  struct SetEntry *set;
+  struct SetHandle *sh = GNUNET_new (struct SetHandle);
+
+  sh->h = copy;
+  GNUNET_CONTAINER_DLL_insert (task->step->session->set_handles_head,
+                               task->step->session->set_handles_tail,
+                               sh);
+
+  GNUNET_free (scc);
+  set = GNUNET_new (struct SetEntry);
+  set->h = copy;
+  set->key = dst_set_key;
+  put_set (task->step->session, set);
+
+  task->start (task);
+}
+
+
+/**
+ * Call the start function of the given
+ * task again after we created a copy of the given set.
+ */
+static void
+create_set_copy_for_task (struct TaskEntry *task,
+                          struct SetKey *src_set_key,
+                          struct SetKey *dst_set_key)
+{
+  struct SetEntry *src_set;
+  struct SetCopyCls *scc = GNUNET_new (struct SetCopyCls);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Copying set {%s} to {%s} for task {%s}\n",
+              debug_str_set_key (src_set_key),
+              debug_str_set_key (dst_set_key),
+              debug_str_task_key (&task->key));
+
+  scc->task = task;
+  scc->dst_set_key = *dst_set_key;
+  src_set = lookup_set (task->step->session, src_set_key);
+  GNUNET_assert (NULL != src_set);
+  GNUNET_SET_copy_lazy (src_set->h,
+                        set_copy_cb,
+                        scc);
+}
+
+
+struct SetMutationProgressCls
+{
+  int num_pending;
+  /**
+   * Task to finish once all changes are through.
+   */
+  struct TaskEntry *task;
+};
+
+
+static void
+set_mutation_done (void *cls)
+{
+  struct SetMutationProgressCls *pc = cls;
+
+  GNUNET_assert (pc->num_pending > 0);
+
+  pc->num_pending--;
+
+  if (0 == pc->num_pending)
+  {
+    struct TaskEntry *task = pc->task;
+    GNUNET_free (pc);
+    finish_task (task);
+  }
+}
+
+
+static void
+try_finish_step_early (struct Step *step)
+{
+  if (GNUNET_YES == step->is_running)
+    return;
+  if (GNUNET_YES == step->is_finished)
+    return;
+  if (GNUNET_NO == step->early_finishable)
+    return;
+
+  step->is_finished = GNUNET_YES;
+
+#ifdef GNUNET_EXTRA_LOGGING
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Finishing step `%s' early.\n",
+              step->debug_name);
+#endif
+
+  for (unsigned int i = 0; i < step->subordinates_len; i++)
+  {
+    GNUNET_assert (step->subordinates[i]->pending_prereq > 0);
+    step->subordinates[i]->pending_prereq--;
+#ifdef GNUNET_EXTRA_LOGGING
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Decreased pending_prereq to %u for step `%s'.\n",
+                (unsigned int) step->subordinates[i]->pending_prereq,
+                step->subordinates[i]->debug_name);
+#endif
+    try_finish_step_early (step->subordinates[i]);
+  }
+
+  // XXX: maybe schedule as task to avoid recursion?
+  run_ready_steps (step->session);
+}
+
+
+static void
+finish_step (struct Step *step)
+{
+  GNUNET_assert (step->finished_tasks == step->tasks_len);
+  GNUNET_assert (GNUNET_YES == step->is_running);
+  GNUNET_assert (GNUNET_NO == step->is_finished);
+
+#ifdef GNUNET_EXTRA_LOGGING
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "All tasks of step `%s' with %u subordinates finished.\n",
+              step->debug_name,
+              step->subordinates_len);
+#endif
+
+  for (unsigned int i = 0; i < step->subordinates_len; i++)
+  {
+    GNUNET_assert (step->subordinates[i]->pending_prereq > 0);
+    step->subordinates[i]->pending_prereq--;
+#ifdef GNUNET_EXTRA_LOGGING
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Decreased pending_prereq to %u for step `%s'.\n",
+                (unsigned int) step->subordinates[i]->pending_prereq,
+                step->subordinates[i]->debug_name);
+#endif
+  }
+
+  step->is_finished = GNUNET_YES;
+
+  // XXX: maybe schedule as task to avoid recursion?
+  run_ready_steps (step->session);
+}
+
+
+/**
+ * Apply the result from one round of gradecasts (i.e. every peer
+ * should have gradecasted) to the peer's current set.
+ *
+ * @param task the task with context information
+ */
+static void
+task_start_apply_round (struct TaskEntry *task)
+{
+  struct ConsensusSession *session = task->step->session;
+  struct SetKey sk_in;
+  struct SetKey sk_out;
+  struct RfnKey rk_in;
+  struct SetEntry *set_out;
+  struct ReferendumEntry *rfn_in;
+  struct GNUNET_CONTAINER_MultiHashMapIterator *iter;
+  struct RfnElementInfo *ri;
+  struct SetMutationProgressCls *progress_cls;
+  uint16_t worst_majority = UINT16_MAX;
+
+  sk_in = (struct SetKey) { SET_KIND_CURRENT, task->key.repetition };
+  rk_in = (struct RfnKey) { RFN_KIND_GRADECAST_RESULT, task->key.repetition };
+  sk_out = (struct SetKey) { SET_KIND_CURRENT, task->key.repetition + 1 };
+
+  set_out = lookup_set (session, &sk_out);
+  if (NULL == set_out)
+  {
+    create_set_copy_for_task (task,
+                              &sk_in,
+                              &sk_out);
+    return;
+  }
+
+  rfn_in = lookup_rfn (session, &rk_in);
+  GNUNET_assert (NULL != rfn_in);
+
+  progress_cls = GNUNET_new (struct SetMutationProgressCls);
+  progress_cls->task = task;
+
+  iter = GNUNET_CONTAINER_multihashmap_iterator_create (rfn_in->rfn_elements);
+
+  while (GNUNET_YES ==
+         GNUNET_CONTAINER_multihashmap_iterator_next (iter,
+                                                      NULL,
+                                                      (const void **) &ri))
+  {
+    uint16_t majority_num;
+    enum ReferendumVote majority_vote;
+
+    rfn_majority (rfn_in, ri, &majority_num, &majority_vote);
+
+    if (worst_majority > majority_num)
+      worst_majority = majority_num;
+
+    switch (majority_vote)
+    {
+    case VOTE_ADD:
+      progress_cls->num_pending++;
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_SET_add_element (set_out->h,
+                                             ri->element,
+                                             &set_mutation_done,
+                                             progress_cls));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: apply round: adding element %s with %u-majority.\n",
+                  session->local_peer_idx,
+                  debug_str_element (ri->element), majority_num);
+      break;
+
+    case VOTE_REMOVE:
+      progress_cls->num_pending++;
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_SET_remove_element (set_out->h,
+                                                ri->element,
+                                                &set_mutation_done,
+                                                progress_cls));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: apply round: deleting element %s with %u-majority.\n",
+                  session->local_peer_idx,
+                  debug_str_element (ri->element), majority_num);
+      break;
+
+    case VOTE_STAY:
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: apply round: keeping element %s with %u-majority.\n",
+                  session->local_peer_idx,
+                  debug_str_element (ri->element), majority_num);
+      // do nothing
+      break;
+
+    default:
+      GNUNET_assert (0);
+      break;
+    }
+  }
+
+  if (0 == progress_cls->num_pending)
+  {
+    // call closure right now, no pending ops
+    GNUNET_free (progress_cls);
+    finish_task (task);
+  }
+
+  {
+    uint16_t thresh = (session->num_peers / 3) * 2;
+
+    if (worst_majority >= thresh)
+    {
+      switch (session->early_stopping)
+      {
+      case EARLY_STOPPING_NONE:
+        session->early_stopping = EARLY_STOPPING_ONE_MORE;
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                    "P%u: Stopping early (after one more superround)\n",
+                    session->local_peer_idx);
+        break;
+
+      case EARLY_STOPPING_ONE_MORE:
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                    "P%u: finishing steps due to early finish\n",
+                    session->local_peer_idx);
+        session->early_stopping = EARLY_STOPPING_DONE;
+        {
+          struct Step *step;
+          for (step = session->steps_head; NULL != step; step = step->next)
+            try_finish_step_early (step);
+        }
+        break;
+
+      case EARLY_STOPPING_DONE:
+        /* We shouldn't be here anymore after early stopping */
+        GNUNET_break (0);
+        break;
+
+      default:
+        GNUNET_assert (0);
+        break;
+      }
+    }
+    else if (EARLY_STOPPING_NONE != session->early_stopping)
+    {
+      // Our assumption about the number of bad peers
+      // has been broken.
+      GNUNET_break_op (0);
+    }
+    else
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "P%u: NOT finishing early (majority not good enough)\n",
+                  session->local_peer_idx);
+    }
+  }
+  GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
+}
+
+
+static void
+task_start_grade (struct TaskEntry *task)
+{
+  struct ConsensusSession *session = task->step->session;
+  struct ReferendumEntry *output_rfn;
+  struct ReferendumEntry *input_rfn;
+  struct DiffEntry *input_diff;
+  struct RfnKey rfn_key;
+  struct DiffKey diff_key;
+  struct GNUNET_CONTAINER_MultiHashMapIterator *iter;
+  struct RfnElementInfo *ri;
+  unsigned int gradecast_confidence = 2;
+
+  rfn_key = (struct RfnKey) { RFN_KIND_GRADECAST_RESULT, task->key.repetition };
+  output_rfn = lookup_rfn (session, &rfn_key);
+  if (NULL == output_rfn)
+  {
+    output_rfn = rfn_create (session->num_peers);
+    output_rfn->key = rfn_key;
+    put_rfn (session, output_rfn);
+  }
+
+  diff_key = (struct DiffKey) { DIFF_KIND_LEADER_PROPOSAL, task->key.repetition,
+                                task->key.leader };
+  input_diff = lookup_diff (session, &diff_key);
+  GNUNET_assert (NULL != input_diff);
+
+  rfn_key = (struct RfnKey) { RFN_KIND_ECHO, task->key.repetition,
+                              task->key.leader };
+  input_rfn = lookup_rfn (session, &rfn_key);
+  GNUNET_assert (NULL != input_rfn);
+
+  iter = GNUNET_CONTAINER_multihashmap_iterator_create (
+    input_rfn->rfn_elements);
+
+  apply_diff_to_rfn (input_diff, output_rfn, task->key.leader,
+                     session->num_peers);
+
+  while (GNUNET_YES ==
+         GNUNET_CONTAINER_multihashmap_iterator_next (iter,
+                                                      NULL,
+                                                      (const void **) &ri))
+  {
+    uint16_t majority_num;
+    enum ReferendumVote majority_vote;
+
+    // XXX: we need contested votes and non-contested votes here
+    rfn_majority (input_rfn, ri, &majority_num, &majority_vote);
+
+    if (majority_num <= session->num_peers / 3)
+      majority_vote = VOTE_REMOVE;
+
+    switch (majority_vote)
+    {
+    case VOTE_STAY:
+      break;
+
+    case VOTE_ADD:
+      rfn_vote (output_rfn, task->key.leader, VOTE_ADD, ri->element);
+      break;
+
+    case VOTE_REMOVE:
+      rfn_vote (output_rfn, task->key.leader, VOTE_REMOVE, ri->element);
+      break;
+
+    default:
+      GNUNET_assert (0);
+      break;
+    }
+  }
+  GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
+
+  {
+    uint16_t noncontested;
+    noncontested = rfn_noncontested (input_rfn);
+    if (noncontested < (session->num_peers / 3) * 2)
+    {
+      gradecast_confidence = GNUNET_MIN (1, gradecast_confidence);
+    }
+    if (noncontested < (session->num_peers / 3) + 1)
+    {
+      gradecast_confidence = 0;
+    }
+  }
+
+  if (gradecast_confidence >= 1)
+    rfn_commit (output_rfn, task->key.leader);
+
+  if (gradecast_confidence <= 1)
+    session->peers_blacklisted[task->key.leader] = GNUNET_YES;
+
+  finish_task (task);
+}
+
+
+static void
+task_start_reconcile (struct TaskEntry *task)
+{
+  struct SetEntry *input;
+  struct SetOpCls *setop = &task->cls.setop;
+  struct ConsensusSession *session = task->step->session;
+
+  input = lookup_set (session, &setop->input_set);
+  GNUNET_assert (NULL != input);
+  GNUNET_assert (NULL != input->h);
+
+  /* We create the outputs for the operation here
+     (rather than in the set operation callback)
+     because we want something valid in there, even
+     if the other peer doesn't talk to us */
+
+  if (SET_KIND_NONE != setop->output_set.set_kind)
+  {
+    /* If we don't have an existing output set,
+       we clone the input set. */
+    if (NULL == lookup_set (session, &setop->output_set))
+    {
+      create_set_copy_for_task (task,
+                                &setop->input_set,
+                                &setop->output_set);
+      return;
+    }
+  }
+
+  if (RFN_KIND_NONE != setop->output_rfn.rfn_kind)
+  {
+    if (NULL == lookup_rfn (session, &setop->output_rfn))
+    {
+      struct ReferendumEntry *rfn;
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: output rfn <%s> missing, creating.\n",
+                  session->local_peer_idx,
+                  debug_str_rfn_key (&setop->output_rfn));
+
+      rfn = rfn_create (session->num_peers);
+      rfn->key = setop->output_rfn;
+      put_rfn (session, rfn);
+    }
+  }
+
+  if (DIFF_KIND_NONE != setop->output_diff.diff_kind)
+  {
+    if (NULL == lookup_diff (session, &setop->output_diff))
+    {
+      struct DiffEntry *diff;
+
+      diff = diff_create ();
+      diff->key = setop->output_diff;
+      put_diff (session, diff);
+    }
+  }
+
+  if ((task->key.peer1 == session->local_peer_idx) && (task->key.peer2 ==
+                                                       session->local_peer_idx))
+  {
+    /* XXX: mark the corresponding rfn as committed if necessary */
+    finish_task (task);
+    return;
+  }
+
+  if (task->key.peer1 == session->local_peer_idx)
+  {
+    struct GNUNET_CONSENSUS_RoundContextMessage rcm;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%u: Looking up set {%s} to run remote union\n",
+                session->local_peer_idx,
+                debug_str_set_key (&setop->input_set));
+    rcm.header.type = htons (GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_ROUND_CONTEXT);
+    rcm.header.size = htons (sizeof(rcm));
+    rcm.kind = htons (task->key.kind);
+    rcm.peer1 = htons (task->key.peer1);
+    rcm.peer2 = htons (task->key.peer2);
+    rcm.leader = htons (task->key.leader);
+    rcm.repetition = htons (task->key.repetition);
+    rcm.is_contested = htons (0);
+
+    GNUNET_assert (NULL == setop->op);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%u: initiating set op with P%u, our set is %s\n",
+                session->local_peer_idx,
+                task->key.peer2,
+                debug_str_set_key (&setop->input_set));
+
+    struct GNUNET_SET_Option opts[] = {
+      { GNUNET_SET_OPTION_BYZANTINE, { .num = session->lower_bound } },
+      { GNUNET_SET_OPTION_END },
+    };
+
+    // XXX: maybe this should be done while
+    // setting up tasks alreays?
+    setop->op = GNUNET_SET_prepare (&session->peers[task->key.peer2],
+                                    &session->global_id,
+                                    &rcm.header,
+                                    GNUNET_SET_RESULT_SYMMETRIC,
+                                    opts,
+                                    set_result_cb,
+                                    task);
+
+    commit_set (session, task);
+  }
+  else if (task->key.peer2 == session->local_peer_idx)
+  {
+    /* Wait for the other peer to contact us */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "P%u: waiting set op with P%u\n",
+                session->local_peer_idx, task->key.peer1);
+
+    if (NULL != setop->op)
+    {
+      commit_set (session, task);
+    }
+  }
+  else
+  {
+    /* We made an error while constructing the task graph. */
+    GNUNET_assert (0);
+  }
+}
+
+
+static void
+task_start_eval_echo (struct TaskEntry *task)
+{
+  struct GNUNET_CONTAINER_MultiHashMapIterator *iter;
+  struct ReferendumEntry *input_rfn;
+  struct RfnElementInfo *ri;
+  struct SetEntry *output_set;
+  struct SetMutationProgressCls *progress_cls;
+  struct ConsensusSession *session = task->step->session;
+  struct SetKey sk_in;
+  struct SetKey sk_out;
+  struct RfnKey rk_in;
+
+  sk_in = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, task->key.repetition,
+                            task->key.leader };
+  sk_out = (struct SetKey) { SET_KIND_ECHO_RESULT, task->key.repetition,
+                             task->key.leader };
+  output_set = lookup_set (session, &sk_out);
+  if (NULL == output_set)
+  {
+    create_set_copy_for_task (task,
+                              &sk_in,
+                              &sk_out);
+    return;
+  }
+
+  {
+    // FIXME: should be marked as a shallow copy, so
+    // we can destroy everything correctly
+    struct SetEntry *last_set = GNUNET_new (struct SetEntry);
+
+    last_set->h = output_set->h;
+    last_set->key = (struct SetKey) { SET_KIND_LAST_GRADECAST };
+    put_set (session, last_set);
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Evaluating referendum in Task {%s}\n",
+              debug_str_task_key (&task->key));
+
+  progress_cls = GNUNET_new (struct SetMutationProgressCls);
+  progress_cls->task = task;
+  rk_in = (struct RfnKey) { RFN_KIND_ECHO, task->key.repetition,
+                            task->key.leader };
+  input_rfn = lookup_rfn (session, &rk_in);
+  GNUNET_assert (NULL != input_rfn);
+  iter = GNUNET_CONTAINER_multihashmap_iterator_create (
+    input_rfn->rfn_elements);
+  GNUNET_assert (NULL != iter);
+
+  while (GNUNET_YES ==
+         GNUNET_CONTAINER_multihashmap_iterator_next (iter,
+                                                      NULL,
+                                                      (const void **) &ri))
+  {
+    enum ReferendumVote majority_vote;
+    uint16_t majority_num;
+
+    rfn_majority (input_rfn, ri, &majority_num, &majority_vote);
+
+    if (majority_num < session->num_peers / 3)
+    {
+      /* It is not the case that all nonfaulty peers
+         echoed the same value.  Since we're doing a set reconciliation, we
+         can't simply send "nothing" for the value.  Thus we mark our 'confirm'
+         reconciliation as contested.  Other peers might not know that the
+         leader is faulty, thus we still re-distribute in the confirmation
+         round. *///
+      output_set->is_contested = GNUNET_YES;
+    }
+
+    switch (majority_vote)
+    {
+    case VOTE_ADD:
+      progress_cls->num_pending++;
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_SET_add_element (output_set->h,
+                                             ri->element,
+                                             set_mutation_done,
+                                             progress_cls));
+      break;
+
+    case VOTE_REMOVE:
+      progress_cls->num_pending++;
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_SET_remove_element (output_set->h,
+                                                ri->element,
+                                                set_mutation_done,
+                                                progress_cls));
+      break;
+
+    case VOTE_STAY:
+      /* Nothing to do. */
+      break;
+
+    default:
+      /* not reached */
+      GNUNET_assert (0);
+    }
+  }
+
+  GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
+
+  if (0 == progress_cls->num_pending)
+  {
+    // call closure right now, no pending ops
+    GNUNET_free (progress_cls);
+    finish_task (task);
+  }
+}
+
+
+static void
+task_start_finish (struct TaskEntry *task)
+{
+  struct SetEntry *final_set;
+  struct ConsensusSession *session = task->step->session;
+
+  final_set = lookup_set (session,
+                          &task->cls.finish.input_set);
+  GNUNET_assert (NULL != final_set);
+  GNUNET_SET_iterate (final_set->h,
+                      &send_to_client_iter,
+                      task);
+}
+
+
+static void
+start_task (struct ConsensusSession *session,
+            struct TaskEntry *task)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "P%u: starting task {%s}\n",
+              session->local_peer_idx,
+              debug_str_task_key (&task->key));
+  GNUNET_assert (GNUNET_NO == task->is_started);
+  GNUNET_assert (GNUNET_NO == task->is_finished);
+  GNUNET_assert (NULL != task->start);
+  task->start (task);
+  task->is_started = GNUNET_YES;
+}
+
+
+/*
+ * Run all steps of the session that don't any
+ * more dependencies.
+ */
+static void
+run_ready_steps (struct ConsensusSession *session)
+{
+  struct Step *step;
+
+  step = session->steps_head;
+
+  while (NULL != step)
+  {
+    if ((GNUNET_NO == step->is_running) && (0 == step->pending_prereq) &&
+        (GNUNET_NO == step->is_finished))
+    {
+      GNUNET_assert (0 == step->finished_tasks);
+
+#ifdef GNUNET_EXTRA_LOGGING
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "P%u: Running step `%s' of round %d with %d tasks and %d subordinates\n",
+                  session->local_peer_idx,
+                  step->debug_name,
+                  step->round, step->tasks_len, step->subordinates_len);
+#endif
+
+      step->is_running = GNUNET_YES;
+      for (size_t i = 0; i < step->tasks_len; i++)
+        start_task (session, step->tasks[i]);
+
+      /* Sometimes there is no task to trigger finishing the step, so we have to do it here. */
+      if ((step->finished_tasks == step->tasks_len) && (GNUNET_NO ==
+                                                        step->is_finished))
+        finish_step (step);
+
+      /* Running the next ready steps will be triggered by task completion */
+      return;
+    }
+    step = step->next;
+  }
+
+  return;
+}
+
+
+static void
+finish_task (struct TaskEntry *task)
+{
+  GNUNET_assert (GNUNET_NO == task->is_finished);
+  task->is_finished = GNUNET_YES;
+  task->step->finished_tasks++;
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "P%u: Finishing Task {%s} (now %u/%u tasks finished in step)\n",
+              task->step->session->local_peer_idx,
+              debug_str_task_key (&task->key),
+              (unsigned int) task->step->finished_tasks,
+              (unsigned int) task->step->tasks_len);
+
+  if (task->step->finished_tasks == task->step->tasks_len)
+    finish_step (task->step);
+}
+
+
+/**
+ * Search peer in the list of peers in session.
+ *
+ * @param peer peer to find
+ * @param session session with peer
+ * @return index of peer, -1 if peer is not in session
+ */
+static int
+get_peer_idx (const struct GNUNET_PeerIdentity *peer,
+              const struct ConsensusSession *session)
+{
+  for (int i = 0; i < session->num_peers; i++)
+    if (0 == GNUNET_memcmp (peer, &session->peers[i]))
+      return i;
+  return -1;
+}
+
+
+/**
+ * Compute a global, (hopefully) unique consensus session id,
+ * from the local id of the consensus session, and the identities of all participants.
+ * Thus, if the local id of two consensus sessions coincide, but are not comprised of
+ * exactly the same peers, the global id will be different.
+ *
+ * @param session session to generate the global id for
+ * @param local_session_id local id of the consensus session
+ */
+static void
+compute_global_id (struct ConsensusSession *session,
+                   const struct GNUNET_HashCode *local_session_id)
+{
+  const char *salt = "gnunet-service-consensus/session_id";
+
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CRYPTO_kdf (&session->global_id,
+                                    sizeof(struct GNUNET_HashCode),
+                                    salt,
+                                    strlen (salt),
+                                    session->peers,
+                                    session->num_peers * sizeof(struct
+                                                                GNUNET_PeerIdentity),
+                                    local_session_id,
+                                    sizeof(struct GNUNET_HashCode),
+                                    NULL));
+}
+
+
+/**
+ * Compare two peer identities (for qsort()).
+ *
+ * @param h1 some peer identity
+ * @param h2 some peer identity
+ * @return 1 if h1 > h2, -1 if h1 < h2 and 0 if h1 == h2.
+ */
+static int
+peer_id_cmp (const void *h1,
+             const void *h2)
+{
+  return memcmp (h1, h2, sizeof(struct GNUNET_PeerIdentity));
+}
+
+
+/**
+ * Create the sorted list of peers for the session,
+ * add the local peer if not in the join message.
+ *
+ * @param session session to initialize
+ * @param join_msg join message with the list of peers participating at the end
+ */
+static void
+initialize_session_peer_list (
+  struct ConsensusSession *session,
+  const struct GNUNET_CONSENSUS_JoinMessage *join_msg)
+{
+  const struct GNUNET_PeerIdentity *msg_peers
+    = (const struct GNUNET_PeerIdentity *) &join_msg[1];
+  int local_peer_in_list;
+
+  session->num_peers = ntohl (join_msg->num_peers);
+
+  /* Peers in the join message, may or may not include the local peer,
+     Add it if it is missing. */
+  local_peer_in_list = GNUNET_NO;
+  for (unsigned int i = 0; i < session->num_peers; i++)
+  {
+    if (0 == GNUNET_memcmp (&msg_peers[i],
+                            &my_peer))
+    {
+      local_peer_in_list = GNUNET_YES;
+      break;
+    }
+  }
+  if (GNUNET_NO == local_peer_in_list)
+    session->num_peers++;
+
+  session->peers = GNUNET_new_array (session->num_peers,
+                                     struct GNUNET_PeerIdentity);
+  if (GNUNET_NO == local_peer_in_list)
+    session->peers[session->num_peers - 1] = my_peer;
+  GNUNET_memcpy (session->peers,
+                 msg_peers,
+                 ntohl (join_msg->num_peers)
+                 * sizeof(struct GNUNET_PeerIdentity));
+  qsort (session->peers,
+         session->num_peers,
+         sizeof (struct GNUNET_PeerIdentity),
+         &peer_id_cmp);
+}
+
+
+static struct TaskEntry *
+lookup_task (const struct ConsensusSession *session,
+             const struct TaskKey *key)
+{
+  struct GNUNET_HashCode hash;
+
+  GNUNET_CRYPTO_hash (key,
+                      sizeof(struct TaskKey),
+                      &hash);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Looking up task hash %s\n",
+              GNUNET_h2s (&hash));
+  return GNUNET_CONTAINER_multihashmap_get (session->taskmap,
+                                            &hash);
+}
+
+
+/**
+ * Called when another peer wants to do a set operation with the
+ * local peer.
+ *
+ * @param cls closure
+ * @param other_peer the other peer
+ * @param context_msg message with application specific information from
+ *        the other peer
+ * @param request request from the other peer, use GNUNET_SET_accept
+ *        to accept it, otherwise the request will be refused
+ *        Note that we don't use a return value here, as it is also
+ *        necessary to specify the set we want to do the operation with,
+ *        which sometimes can be derived from the context message.
+ *        Also necessary to specify the timeout.
+ */
+static void
+set_listen_cb (void *cls,
+               const struct GNUNET_PeerIdentity *other_peer,
+               const struct GNUNET_MessageHeader *context_msg,
+               struct GNUNET_SET_Request *request)
+{
+  struct ConsensusSession *session = cls;
+  struct TaskKey tk;
+  struct TaskEntry *task;
+  struct GNUNET_CONSENSUS_RoundContextMessage *cm;
+
+  if (NULL == context_msg)
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+
+  if (GNUNET_MESSAGE_TYPE_CONSENSUS_P2P_ROUND_CONTEXT != ntohs (
+        context_msg->type))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+
+  if (sizeof(struct GNUNET_CONSENSUS_RoundContextMessage) != ntohs (
+        context_msg->size))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+
+  cm = (struct GNUNET_CONSENSUS_RoundContextMessage *) context_msg;
+
+  tk = ((struct TaskKey) {
+    .kind = ntohs (cm->kind),
+    .peer1 = ntohs (cm->peer1),
+    .peer2 = ntohs (cm->peer2),
+    .repetition = ntohs (cm->repetition),
+    .leader = ntohs (cm->leader),
+  });
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "P%u: got req for task %s\n",
+              session->local_peer_idx, debug_str_task_key (&tk));
+
+  task = lookup_task (session, &tk);
+
+  if (NULL == task)
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+
+  if (GNUNET_YES == task->is_finished)
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+
+  if (task->key.peer2 != session->local_peer_idx)
+  {
+    /* We're being asked, so we must be the 2nd peer. */
+    GNUNET_break_op (0);
+    return;
+  }
+
+  GNUNET_assert (! ((task->key.peer1 == session->local_peer_idx) &&
+                    (task->key.peer2 == session->local_peer_idx)));
+
+  struct GNUNET_SET_Option opts[] = {
+    { GNUNET_SET_OPTION_BYZANTINE, { .num = session->lower_bound } },
+    { GNUNET_SET_OPTION_END },
+  };
+
+  task->cls.setop.op = GNUNET_SET_accept (request,
+                                          GNUNET_SET_RESULT_SYMMETRIC,
+                                          opts,
+                                          &set_result_cb,
+                                          task);
+
+  /* If the task hasn't been started yet,
+     we wait for that until we commit. */
+
+  if (GNUNET_YES == task->is_started)
+  {
+    commit_set (session, task);
+  }
+}
+
+
+static void
+put_task (struct GNUNET_CONTAINER_MultiHashMap *taskmap,
+          struct TaskEntry *t)
+{
+  struct GNUNET_HashCode round_hash;
+  struct Step *s;
+
+  GNUNET_assert (NULL != t->step);
+  t = GNUNET_memdup (t, sizeof(struct TaskEntry));
+  s = t->step;
+  if (s->tasks_len == s->tasks_cap)
+  {
+    unsigned int target_size = 3 * (s->tasks_cap + 1) / 2;
+    GNUNET_array_grow (s->tasks,
+                       s->tasks_cap,
+                       target_size);
+  }
+
+#ifdef GNUNET_EXTRA_LOGGING
+  GNUNET_assert (NULL != s->debug_name);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Putting task <%s> into step `%s'\n",
+              debug_str_task_key (&t->key),
+              s->debug_name);
+#endif
+
+  s->tasks[s->tasks_len] = t;
+  s->tasks_len++;
+
+  GNUNET_CRYPTO_hash (&t->key,
+                      sizeof(struct TaskKey),
+                      &round_hash);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multihashmap_put (taskmap,
+                                                    &round_hash,
+                                                    t,
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+}
+
+
+static void
+install_step_timeouts (struct ConsensusSession *session)
+{
+  /* Given the fully constructed task graph
+     with rounds for tasks, we can give the tasks timeouts. */
+
+  // unsigned int max_round;
+
+  /* XXX: implement! */
+}
+
+
+/*
+ * Arrange two peers in some canonical order.
+ */
+static void
+arrange_peers (uint16_t *p1,
+               uint16_t *p2,
+               uint16_t n)
+{
+  uint16_t a;
+  uint16_t b;
+
+  GNUNET_assert (*p1 < n);
+  GNUNET_assert (*p2 < n);
+
+  if (*p1 < *p2)
+  {
+    a = *p1;
+    b = *p2;
+  }
+  else
+  {
+    a = *p2;
+    b = *p1;
+  }
+
+  /* For uniformly random *p1, *p2,
+     this condition is true with 50% chance */
+  if (((b - a) + n) % n <= n / 2)
+  {
+    *p1 = a;
+    *p2 = b;
+  }
+  else
+  {
+    *p1 = b;
+    *p2 = a;
+  }
+}
+
+
+/**
+ * Record @a dep as a dependency of @a step.
+ */
+static void
+step_depend_on (struct Step *step,
+                struct Step *dep)
+{
+  /* We're not checking for cyclic dependencies,
+     but this is a cheap sanity check. */
+  GNUNET_assert (step != dep);
+  GNUNET_assert (NULL != step);
+  GNUNET_assert (NULL != dep);
+  GNUNET_assert (dep->round <= step->round);
+
+#ifdef GNUNET_EXTRA_LOGGING
+  /* Make sure we have complete debugging information.
+     Also checks that we don't screw up too badly
+     constructing the task graph. */
+  GNUNET_assert (NULL != step->debug_name);
+  GNUNET_assert (NULL != dep->debug_name);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Making step `%s' depend on `%s'\n",
+              step->debug_name,
+              dep->debug_name);
+#endif
+
+  if (dep->subordinates_cap == dep->subordinates_len)
+  {
+    unsigned int target_size = 3 * (dep->subordinates_cap + 1) / 2;
+    GNUNET_array_grow (dep->subordinates,
+                       dep->subordinates_cap,
+                       target_size);
+  }
+
+  GNUNET_assert (dep->subordinates_len <= dep->subordinates_cap);
+
+  dep->subordinates[dep->subordinates_len] = step;
+  dep->subordinates_len++;
+
+  step->pending_prereq++;
+}
+
+
+static struct Step *
+create_step (struct ConsensusSession *session,
+             int round,
+             int early_finishable)
+{
+  struct Step *step;
+
+  step = GNUNET_new (struct Step);
+  step->session = session;
+  step->round = round;
+  step->early_finishable = early_finishable;
+  GNUNET_CONTAINER_DLL_insert_tail (session->steps_head,
+                                    session->steps_tail,
+                                    step);
+  return step;
+}
+
+
+/**
+ * Construct the task graph for a single gradecast.
+ */
+static void
+construct_task_graph_gradecast (struct ConsensusSession *session,
+                                uint16_t rep,
+                                uint16_t lead,
+                                struct Step *step_before,
+                                struct Step *step_after)
+{
+  uint16_t n = session->num_peers;
+  uint16_t me = session->local_peer_idx;
+  uint16_t p1;
+  uint16_t p2;
+  /* The task we're currently setting up. */
+  struct TaskEntry task;
+  struct Step *step;
+  struct Step *prev_step;
+  uint16_t round;
+
+  round = step_before->round + 1;
+
+  /* gcast step 1: leader disseminates */
+  step = create_step (session,
+                      round,
+                      GNUNET_YES);
+#ifdef GNUNET_EXTRA_LOGGING
+  GNUNET_asprintf (&step->debug_name,
+                   "disseminate leader %u rep %u",
+                   lead,
+                   rep);
+#endif
+  step_depend_on (step,
+                  step_before);
+
+  if (lead == me)
+  {
+    for (unsigned int k = 0; k < n; k++)
+    {
+      if (k == me)
+        continue;
+      p1 = me;
+      p2 = k;
+      arrange_peers (&p1, &p2, n);
+      task = ((struct TaskEntry) {
+        .step = step,
+        .start = task_start_reconcile,
+        .cancel = task_cancel_reconcile,
+        .key = (struct TaskKey) { PHASE_KIND_GRADECAST_LEADER, p1, p2, rep,
+                                  me },
+      });
+      task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, rep };
+      put_task (session->taskmap, &task);
+    }
+    /* We run this task to make sure that the leader
+       has the stored the SET_KIND_LEADER set of himself,
+       so it can participate in the rest of the gradecast
+       without the code having to handle any special cases. */
+    task = ((struct TaskEntry) {
+      .step = step,
+      .key = (struct TaskKey) { PHASE_KIND_GRADECAST_LEADER, me, me, rep, me },
+      .start = task_start_reconcile,
+      .cancel = task_cancel_reconcile,
+    });
+    task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, rep };
+    task.cls.setop.output_set = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, rep,
+                                                  me };
+    task.cls.setop.output_diff = (struct DiffKey) { DIFF_KIND_LEADER_PROPOSAL,
+                                                    rep, me };
+    put_task (session->taskmap, &task);
+  }
+  else
+  {
+    p1 = me;
+    p2 = lead;
+    arrange_peers (&p1, &p2, n);
+    task = ((struct TaskEntry) {
+      .step = step,
+      .key = (struct TaskKey) { PHASE_KIND_GRADECAST_LEADER, p1, p2, rep,
+                                lead },
+      .start = task_start_reconcile,
+      .cancel = task_cancel_reconcile,
+    });
+    task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, rep };
+    task.cls.setop.output_set = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, rep,
+                                                  lead };
+    task.cls.setop.output_diff = (struct DiffKey) { DIFF_KIND_LEADER_PROPOSAL,
+                                                    rep, lead };
+    put_task (session->taskmap, &task);
+  }
+
+  /* gcast phase 2: echo */
+  prev_step = step;
+  round += 1;
+  step = create_step (session,
+                      round,
+                      GNUNET_YES);
+#ifdef GNUNET_EXTRA_LOGGING
+  GNUNET_asprintf (&step->debug_name,
+                   "echo leader %u rep %u",
+                   lead,
+                   rep);
+#endif
+  step_depend_on (step,
+                  prev_step);
+
+  for (unsigned int k = 0; k < n; k++)
+  {
+    p1 = k;
+    p2 = me;
+    arrange_peers (&p1, &p2, n);
+    task = ((struct TaskEntry) {
+      .step = step,
+      .key = (struct TaskKey) { PHASE_KIND_GRADECAST_ECHO, p1, p2, rep, lead },
+      .start = task_start_reconcile,
+      .cancel = task_cancel_reconcile,
+    });
+    task.cls.setop.input_set = (struct SetKey) { SET_KIND_LEADER_PROPOSAL, rep,
+                                                 lead };
+    task.cls.setop.output_rfn = (struct RfnKey) { RFN_KIND_ECHO, rep, lead };
+    put_task (session->taskmap, &task);
+  }
+
+  prev_step = step;
+  /* Same round, since step only has local tasks */
+  step = create_step (session, round, GNUNET_YES);
+#ifdef GNUNET_EXTRA_LOGGING
+  GNUNET_asprintf (&step->debug_name, "echo grade leader %u rep %u", lead, rep);
+#endif
+  step_depend_on (step, prev_step);
+
+  arrange_peers (&p1, &p2, n);
+  task = ((struct TaskEntry) {
+    .key = (struct TaskKey) { PHASE_KIND_GRADECAST_ECHO_GRADE, -1, -1, rep,
+                              lead },
+    .step = step,
+    .start = task_start_eval_echo
+  });
+  put_task (session->taskmap, &task);
+
+  prev_step = step;
+  round += 1;
+  step = create_step (session, round, GNUNET_YES);
+#ifdef GNUNET_EXTRA_LOGGING
+  GNUNET_asprintf (&step->debug_name, "confirm leader %u rep %u", lead, rep);
+#endif
+  step_depend_on (step, prev_step);
+
+  /* gcast phase 3: confirmation and grading */
+  for (unsigned int k = 0; k < n; k++)
+  {
+    p1 = k;
+    p2 = me;
+    arrange_peers (&p1, &p2, n);
+    task = ((struct TaskEntry) {
+      .step = step,
+      .start = task_start_reconcile,
+      .cancel = task_cancel_reconcile,
+      .key = (struct TaskKey) { PHASE_KIND_GRADECAST_CONFIRM, p1, p2, rep,
+                                lead },
+    });
+    task.cls.setop.input_set = (struct SetKey) { SET_KIND_ECHO_RESULT, rep,
+                                                 lead };
+    task.cls.setop.output_rfn = (struct RfnKey) { RFN_KIND_CONFIRM, rep, lead };
+    /* If there was at least one element in the echo round that was
+       contested (i.e. it had no n-t majority), then we let the other peers
+       know, and other peers let us know.  The contested flag for each peer is
+       stored in the rfn. */
+    task.cls.setop.transceive_contested = GNUNET_YES;
+    put_task (session->taskmap, &task);
+  }
+
+  prev_step = step;
+  /* Same round, since step only has local tasks */
+  step = create_step (session, round, GNUNET_YES);
+#ifdef GNUNET_EXTRA_LOGGING
+  GNUNET_asprintf (&step->debug_name, "confirm grade leader %u rep %u", lead,
+                   rep);
+#endif
+  step_depend_on (step, prev_step);
+
+  task = ((struct TaskEntry) {
+    .step = step,
+    .key = (struct TaskKey) { PHASE_KIND_GRADECAST_CONFIRM_GRADE, -1, -1, rep,
+                              lead },
+    .start = task_start_grade,
+  });
+  put_task (session->taskmap, &task);
+
+  step_depend_on (step_after, step);
+}
+
+
+static void
+construct_task_graph (struct ConsensusSession *session)
+{
+  uint16_t n = session->num_peers;
+  uint16_t t = n / 3;
+  uint16_t me = session->local_peer_idx;
+  /* The task we're currently setting up. */
+  struct TaskEntry task;
+  /* Current leader */
+  unsigned int lead;
+  struct Step *step;
+  struct Step *prev_step;
+  unsigned int round = 0;
+
+  // XXX: introduce first step,
+  // where we wait for all insert acks
+  // from the set service
+
+  /* faster but brittle all-to-all */
+
+  // XXX: Not implemented yet
+
+  /* all-to-all step */
+
+  step = create_step (session, round, GNUNET_NO);
+
+#ifdef GNUNET_EXTRA_LOGGING
+  step->debug_name = GNUNET_strdup ("all to all");
+#endif
+
+  for (unsigned int i = 0; i < n; i++)
+  {
+    uint16_t p1;
+    uint16_t p2;
+
+    p1 = me;
+    p2 = i;
+    arrange_peers (&p1, &p2, n);
+    task = ((struct TaskEntry) {
+      .key = (struct TaskKey) { PHASE_KIND_ALL_TO_ALL, p1, p2, -1, -1 },
+      .step = step,
+      .start = task_start_reconcile,
+      .cancel = task_cancel_reconcile,
+    });
+    task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, 0 };
+    task.cls.setop.output_set = task.cls.setop.input_set;
+    task.cls.setop.do_not_remove = GNUNET_YES;
+    put_task (session->taskmap, &task);
+  }
+
+  round += 1;
+  prev_step = step;
+  step = create_step (session, round, GNUNET_NO);;
+#ifdef GNUNET_EXTRA_LOGGING
+  step->debug_name = GNUNET_strdup ("all to all 2");
+#endif
+  step_depend_on (step, prev_step);
+
+
+  for (unsigned int i = 0; i < n; i++)
+  {
+    uint16_t p1;
+    uint16_t p2;
+
+    p1 = me;
+    p2 = i;
+    arrange_peers (&p1, &p2, n);
+    task = ((struct TaskEntry) {
+      .key = (struct TaskKey) { PHASE_KIND_ALL_TO_ALL_2, p1, p2, -1, -1 },
+      .step = step,
+      .start = task_start_reconcile,
+      .cancel = task_cancel_reconcile,
+    });
+    task.cls.setop.input_set = (struct SetKey) { SET_KIND_CURRENT, 0 };
+    task.cls.setop.output_set = task.cls.setop.input_set;
+    task.cls.setop.do_not_remove = GNUNET_YES;
+    put_task (session->taskmap, &task);
+  }
+
+  round += 1;
+
+  prev_step = step;
+  step = NULL;
+
+
+  /* Byzantine union */
+
+  /* sequential repetitions of the gradecasts */
+  for (unsigned int i = 0; i < t + 1; i++)
+  {
+    struct Step *step_rep_start;
+    struct Step *step_rep_end;
+
+    /* Every repetition is in a separate round. */
+    step_rep_start = create_step (session, round, GNUNET_YES);
+#ifdef GNUNET_EXTRA_LOGGING
+    GNUNET_asprintf (&step_rep_start->debug_name, "gradecast start rep %u", i);
+#endif
+
+    step_depend_on (step_rep_start, prev_step);
+
+    /* gradecast has three rounds */
+    round += 3;
+    step_rep_end = create_step (session, round, GNUNET_YES);
+#ifdef GNUNET_EXTRA_LOGGING
+    GNUNET_asprintf (&step_rep_end->debug_name, "gradecast end rep %u", i);
+#endif
+
+    /* parallel gradecasts */
+    for (lead = 0; lead < n; lead++)
+      construct_task_graph_gradecast (session, i, lead, step_rep_start,
+                                      step_rep_end);
+
+    task = ((struct TaskEntry) {
+      .step = step_rep_end,
+      .key = (struct TaskKey) { PHASE_KIND_APPLY_REP, -1, -1, i, -1 },
+      .start = task_start_apply_round,
+    });
+    put_task (session->taskmap, &task);
+
+    prev_step = step_rep_end;
+  }
+
+  /* There is no next gradecast round, thus the final
+     start step is the overall end step of the gradecasts */
+  round += 1;
+  step = create_step (session, round, GNUNET_NO);
+#ifdef GNUNET_EXTRA_LOGGING
+  GNUNET_asprintf (&step->debug_name, "finish");
+#endif
+  step_depend_on (step, prev_step);
+
+  task = ((struct TaskEntry) {
+    .step = step,
+    .key = (struct TaskKey) { PHASE_KIND_FINISH, -1, -1, -1, -1 },
+    .start = task_start_finish,
+  });
+  task.cls.finish.input_set = (struct SetKey) { SET_KIND_LAST_GRADECAST };
+
+  put_task (session->taskmap, &task);
+}
+
+
+/**
+ * Check join message.
+ *
+ * @param cls session of client that sent the message
+ * @param m message sent by the client
+ * @return #GNUNET_OK if @a m is well-formed
+ */
+static int
+check_client_join (void *cls,
+                   const struct GNUNET_CONSENSUS_JoinMessage *m)
+{
+  uint32_t listed_peers = ntohl (m->num_peers);
+
+  if ((ntohs (m->header.size) - sizeof(*m)) !=
+      listed_peers * sizeof(struct GNUNET_PeerIdentity))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Called when a client wants to join a consensus session.
+ *
+ * @param cls session of client that sent the message
+ * @param m message sent by the client
+ */
+static void
+handle_client_join (void *cls,
+                    const struct GNUNET_CONSENSUS_JoinMessage *m)
+{
+  struct ConsensusSession *session = cls;
+  struct ConsensusSession *other_session;
+
+  initialize_session_peer_list (session,
+                                m);
+  compute_global_id (session,
+                     &m->session_id);
+
+  /* Check if some local client already owns the session.
+     It is only legal to have a session with an existing global id
+     if all other sessions with this global id are finished.*/
+  for (other_session = sessions_head;
+       NULL != other_session;
+       other_session = other_session->next)
+  {
+    if ( (other_session != session) &&
+         (0 == GNUNET_CRYPTO_hash_cmp (&session->global_id,
+                                       &other_session->global_id)) )
+      break;
+  }
+
+  session->conclude_deadline
+    = GNUNET_TIME_absolute_ntoh (m->deadline);
+  session->conclude_start
+    = GNUNET_TIME_absolute_ntoh (m->start);
+  session->local_peer_idx = get_peer_idx (&my_peer,
+                                          session);
+  GNUNET_assert (-1 != session->local_peer_idx);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Joining consensus session %s containing %u peers as %u with timeout %s\n",
+              GNUNET_h2s (&m->session_id),
+              session->num_peers,
+              session->local_peer_idx,
+              GNUNET_STRINGS_relative_time_to_string (
+                GNUNET_TIME_absolute_get_difference (session->conclude_start,
+                                                     session->conclude_deadline),
+                GNUNET_YES));
+
+  session->set_listener
+    = GNUNET_SET_listen (cfg,
+                         GNUNET_SET_OPERATION_UNION,
+                         &session->global_id,
+                         &set_listen_cb,
+                         session);
+
+  session->setmap = GNUNET_CONTAINER_multihashmap_create (1,
+                                                          GNUNET_NO);
+  session->taskmap = GNUNET_CONTAINER_multihashmap_create (1,
+                                                           GNUNET_NO);
+  session->diffmap = GNUNET_CONTAINER_multihashmap_create (1,
+                                                           GNUNET_NO);
+  session->rfnmap = GNUNET_CONTAINER_multihashmap_create (1,
+                                                          GNUNET_NO);
+
+  {
+    struct SetEntry *client_set;
+
+    client_set = GNUNET_new (struct SetEntry);
+    client_set->h = GNUNET_SET_create (cfg,
+                                       GNUNET_SET_OPERATION_UNION);
+    struct SetHandle *sh = GNUNET_new (struct SetHandle);
+    sh->h = client_set->h;
+    GNUNET_CONTAINER_DLL_insert (session->set_handles_head,
+                                 session->set_handles_tail,
+                                 sh);
+    client_set->key = ((struct SetKey) { SET_KIND_CURRENT, 0, 0 });
+    put_set (session,
+             client_set);
+  }
+
+  session->peers_blacklisted = GNUNET_new_array (session->num_peers,
+                                                 int);
+
+  /* Just construct the task graph,
+     but don't run anything until the client calls conclude. */
+  construct_task_graph (session);
+  GNUNET_SERVICE_client_continue (session->client);
+}
+
+
+/**
+ * Called when a client performs an insert operation.
+ *
+ * @param cls client handle
+ * @param msg message sent by the client
+ * @return #GNUNET_OK (always well-formed)
+ */
+static int
+check_client_insert (void *cls,
+                     const struct GNUNET_CONSENSUS_ElementMessage *msg)
+{
+  return GNUNET_OK;
+}
+
+
+/**
+ * Called when a client performs an insert operation.
+ *
+ * @param cls client handle
+ * @param msg message sent by the client
+ */
+static void
+handle_client_insert (void *cls,
+                      const struct GNUNET_CONSENSUS_ElementMessage *msg)
+{
+  struct ConsensusSession *session = cls;
+  ssize_t element_size;
+  struct GNUNET_SET_Handle *initial_set;
+  struct ConsensusElement *ce;
+
+  if (GNUNET_YES == session->conclude_started)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (session->client);
+    return;
+  }
+  element_size = ntohs (msg->header.size) - sizeof(*msg);
+  ce = GNUNET_malloc (sizeof(struct ConsensusElement) + element_size);
+  GNUNET_memcpy (&ce[1],
+                 &msg[1],
+                 element_size);
+  ce->payload_type = msg->element_type;
+
+  {
+    struct SetKey key = { SET_KIND_CURRENT, 0, 0 };
+    struct SetEntry *entry;
+
+    entry = lookup_set (session,
+                        &key);
+    GNUNET_assert (NULL != entry);
+    initial_set = entry->h;
+  }
+
+  session->num_client_insert_pending++;
+
+  {
+    struct GNUNET_SET_Element element = {
+      .element_type = GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT,
+      .size = sizeof(struct ConsensusElement) + element_size,
+      .data = ce,
+    };
+
+    GNUNET_SET_add_element (initial_set,
+                            &element,
+                            NULL,
+                            NULL);
+#ifdef GNUNET_EXTRA_LOGGING
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "P%u: element %s added\n",
+                session->local_peer_idx,
+                debug_str_element (&element));
+#endif
+  }
+  GNUNET_free (ce);
+  GNUNET_SERVICE_client_continue (session->client);
+}
+
+
+/**
+ * Called when a client performs the conclude operation.
+ *
+ * @param cls client handle
+ * @param message message sent by the client
+ */
+static void
+handle_client_conclude (void *cls,
+                        const struct GNUNET_MessageHeader *message)
+{
+  struct ConsensusSession *session = cls;
+
+  if (GNUNET_YES == session->conclude_started)
+  {
+    /* conclude started twice */
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (session->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "conclude requested\n");
+  session->conclude_started = GNUNET_YES;
+  install_step_timeouts (session);
+  run_ready_steps (session);
+  GNUNET_SERVICE_client_continue (session->client);
+}
+
+
+/**
+ * Called to clean up, after a shutdown has been requested.
+ *
+ * @param cls closure
+ */
+static void
+shutdown_task (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "shutting down\n");
+  GNUNET_STATISTICS_destroy (statistics,
+                             GNUNET_NO);
+  statistics = NULL;
+}
+
+
+/**
+ * Start processing consensus requests.
+ *
+ * @param cls closure
+ * @param c configuration to use
+ * @param service the initialized service
+ */
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_SERVICE_Handle *service)
+{
+  cfg = c;
+  if (GNUNET_OK !=
+      GNUNET_CRYPTO_get_peer_identity (cfg,
+                                       &my_peer))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Could not retrieve host identity\n");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  statistics = GNUNET_STATISTICS_create ("consensus",
+                                         cfg);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
+                                 NULL);
+}
+
+
+/**
+ * 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)
+{
+  struct ConsensusSession *session = GNUNET_new (struct ConsensusSession);
+
+  session->client = c;
+  session->client_mq = mq;
+  GNUNET_CONTAINER_DLL_insert (sessions_head,
+                               sessions_tail,
+                               session);
+  return session;
+}
+
+
+/**
+ * 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)
+{
+  struct ConsensusSession *session = internal_cls;
+
+  if (NULL != session->set_listener)
+  {
+    GNUNET_SET_listen_cancel (session->set_listener);
+    session->set_listener = NULL;
+  }
+  GNUNET_CONTAINER_DLL_remove (sessions_head,
+                               sessions_tail,
+                               session);
+  while (session->set_handles_head)
+  {
+    struct SetHandle *sh = session->set_handles_head;
+
+    session->set_handles_head = sh->next;
+    GNUNET_SET_destroy (sh->h);
+    GNUNET_free (sh);
+  }
+  GNUNET_free (session);
+}
+
+
+/**
+ * Define "main" method using service macro.
+ */
+GNUNET_SERVICE_MAIN (
+  "consensus",
+  GNUNET_SERVICE_OPTION_NONE,
+  &run,
+  &client_connect_cb,
+  &client_disconnect_cb,
+  NULL,
+  GNUNET_MQ_hd_fixed_size (client_conclude,
+                           GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_CONCLUDE,
+                           struct GNUNET_MessageHeader,
+                           NULL),
+  GNUNET_MQ_hd_var_size (client_insert,
+                         GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_INSERT,
+                         struct GNUNET_CONSENSUS_ElementMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (client_join,
+                         GNUNET_MESSAGE_TYPE_CONSENSUS_CLIENT_JOIN,
+                         struct GNUNET_CONSENSUS_JoinMessage,
+                         NULL),
+  GNUNET_MQ_handler_end ());
+
+/* end of gnunet-service-consensus.c */
diff --git a/src/contrib/service/consensus/meson.build b/src/contrib/service/consensus/meson.build
new file mode 100644
index 000000000..86cc0663b
--- /dev/null
+++ b/src/contrib/service/consensus/meson.build
@@ -0,0 +1,66 @@
+libgnunetconsensus_src = ['consensus_api.c']
+
+gnunetserviceconsensus_src = ['gnunet-service-consensus.c']
+
+configure_file(input : 'consensus.conf.in',
+               output : 'consensus.conf',
+               configuration : cdata,
+               install: true,
+               install_dir: pkgcfgdir)
+
+# FIXME needs new seti/setu
+if get_option('monolith')
+  #foreach p : libgnunetconsensus_src + gnunetserviceconsensus_src
+  #  gnunet_src += 'consensus/' + p
+  #endforeach
+endif
+
+libgnunetconsensus = shared_library('gnunetconsensus',
+        libgnunetconsensus_src,
+        soversion: '0',
+        version: '0.0.0',
+        dependencies: libgnunetutil_dep,
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir'))
+pkg.generate(libgnunetconsensus, url: 'https://www.gnunet.org',
+             description : 'Provides API for accessing the consensus service')
+libgnunetarm_dep = declare_dependency(link_with : libgnunetarm)
+libgnunetconsensus_dep = declare_dependency(link_with : libgnunetconsensus)
+
+shared_module('gnunet_plugin_block_consensus',
+              ['plugin_block_consensus.c'],
+              dependencies: [libgnunetutil_dep,
+                             libgnunetblock_dep],
+              include_directories: [incdir, configuration_inc],
+              install:true,
+              install_dir: get_option('libdir')/'gnunet')
+
+executable ('gnunet-service-consensus',
+            gnunetserviceconsensus_src,
+            dependencies: [libgnunetconsensus_dep,
+                           libgnunetutil_dep,
+                           libgnunetset_dep,
+                           libgnunetstatistics_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+
+# FIXME do we need evil stuff and ENABLE_MALICIOUS?
+
+testconsensusapi = executable ('test_consensus_api',
+            ['test_consensus_api.c'],
+            dependencies: [libgnunetconsensus_dep,
+                           libgnunetutil_dep,
+                           libgnunettesting_dep],
+            include_directories: [incdir, configuration_inc],
+            install: false)
+
+configure_file(input : 'test_consensus.conf',
+               output : 'test_consensus.conf',
+               configuration : cdata,
+               install: false)
+
+test('test_consensus_api', testconsensusapi,
+  workdir: meson.current_build_dir(),
+  suite: ['consensus', 'contrib'])
diff --git a/src/contrib/service/consensus/plugin_block_consensus.c b/src/contrib/service/consensus/plugin_block_consensus.c
new file mode 100644
index 000000000..241d8fc7b
--- /dev/null
+++ b/src/contrib/service/consensus/plugin_block_consensus.c
@@ -0,0 +1,222 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2017, 2021 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file consensus/plugin_block_consensus.c
+ * @brief consensus block, either nested block or marker
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "consensus_protocol.h"
+#include "gnunet_block_plugin.h"
+#include "gnunet_block_group_lib.h"
+
+
+/**
+ * Our closure.
+ */
+struct BlockContext
+{
+  /**
+   * Configuration to use.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Lazily initialized block context.
+   */
+  struct GNUNET_BLOCK_Context *bc;
+};
+
+
+
+/**
+ * Function called to validate a query.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param query original query (hash)
+ * @param xquery extrended query data (can be NULL, depending on type)
+ * @param xquery_size number of bytes in @a xquery
+ * @return #GNUNET_OK if the query is fine, #GNUNET_NO if not
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_consensus_check_query (void *cls,
+                                    enum GNUNET_BLOCK_Type type,
+                                    const struct GNUNET_HashCode *query,
+                                    const void *xquery,
+                                    size_t xquery_size)
+{
+  /* consensus does not use queries/DHT */
+  GNUNET_break (0);
+  return GNUNET_SYSERR;
+}
+
+
+/**
+ * Function called to validate a block for storage.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param block block data to validate
+ * @param block_size number of bytes in @a block
+ * @return #GNUNET_OK if the block is fine, #GNUNET_NO if not
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_consensus_check_block (void *cls,
+                                    enum GNUNET_BLOCK_Type type,
+                                    const void *block,
+                                    size_t block_size)
+{
+  struct BlockContext *ctx = cls;
+  const struct ConsensusElement *ce = block;
+
+  if (block_size < sizeof(*ce))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_NO;
+  }
+  if ( (0 != ce->marker) ||
+       (0 == ce->payload_type) )
+    return GNUNET_OK;
+  if (NULL == ctx->bc)
+    ctx->bc = GNUNET_BLOCK_context_create (ctx->cfg);
+  return GNUNET_BLOCK_check_block (ctx->bc,
+                                   ntohl (ce->payload_type),
+                                   &ce[1],
+                                   block_size - sizeof(*ce));
+}
+
+
+/**
+ * Function called to validate a reply to a request.  Note that it is assumed
+ * that the reply has already been matched to the key (and signatures checked)
+ * as it would be done with the GetKeyFunction and the
+ * BlockEvaluationFunction.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param group which block group to use for evaluation
+ * @param query original query (hash)
+ * @param xquery extrended query data (can be NULL, depending on type)
+ * @param xquery_size number of bytes in @a xquery
+ * @param reply_block response to validate
+ * @param reply_block_size number of bytes in @a reply_block
+ * @return characterization of result
+ */
+static enum GNUNET_BLOCK_ReplyEvaluationResult
+block_plugin_consensus_check_reply (
+  void *cls,
+  enum GNUNET_BLOCK_Type type,
+  struct GNUNET_BLOCK_Group *group,
+  const struct GNUNET_HashCode *query,
+  const void *xquery,
+  size_t xquery_size,
+  const void *reply_block,
+  size_t reply_block_size)
+{
+  struct BlockContext *ctx = cls;
+  const struct ConsensusElement *ce = reply_block;
+
+  GNUNET_assert (reply_block_size >= sizeof(struct ConsensusElement));
+  if ( (0 != ce->marker) ||
+       (0 == ce->payload_type) )
+    return GNUNET_BLOCK_REPLY_OK_MORE;
+  if (NULL == ctx->bc)
+    ctx->bc = GNUNET_BLOCK_context_create (ctx->cfg);
+  return GNUNET_BLOCK_check_reply (ctx->bc,
+                                   ntohl (ce->payload_type),
+                                   group,
+                                   query,
+                                   xquery,
+                                   xquery_size,
+                                   &ce[1],
+                                   reply_block_size - sizeof(*ce));
+}
+
+
+/**
+ * Function called to obtain the key for a block.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param block block to get the key for
+ * @param block_size number of bytes in block
+ * @param key set to the key (query) for the given block
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if type not supported
+ *         (or if extracting a key from a block of this type does not work)
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_consensus_get_key (void *cls,
+                                enum GNUNET_BLOCK_Type type,
+                                const void *block,
+                                size_t block_size,
+                                struct GNUNET_HashCode *key)
+{
+  return GNUNET_SYSERR;
+}
+
+
+/**
+ * Entry point for the plugin.
+ */
+void *
+libgnunet_plugin_block_consensus_init (void *cls)
+{
+  static const enum GNUNET_BLOCK_Type types[] = {
+    GNUNET_BLOCK_TYPE_CONSENSUS_ELEMENT,
+    GNUNET_BLOCK_TYPE_ANY       /* end of list */
+  };
+  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
+  struct BlockContext *ctx;
+  struct GNUNET_BLOCK_PluginFunctions *api;
+
+  ctx = GNUNET_new (struct BlockContext);
+  ctx->cfg = cfg;
+  api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions);
+  api->cls = ctx;
+  api->get_key = &block_plugin_consensus_get_key;
+  api->check_query = &block_plugin_consensus_check_query;
+  api->check_block = &block_plugin_consensus_check_block;
+  api->check_reply = &block_plugin_consensus_check_reply;
+  api->types = types;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ */
+void *
+libgnunet_plugin_block_consensus_done (void *cls)
+{
+  struct GNUNET_BLOCK_PluginFunctions *api = cls;
+  struct BlockContext *ctx = api->cls;
+
+  if (NULL != ctx->bc)
+    GNUNET_BLOCK_context_destroy (ctx->bc);
+  GNUNET_free (ctx);
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_block_consensus.c */
diff --git a/src/contrib/service/consensus/test_consensus.conf b/src/contrib/service/consensus/test_consensus.conf
new file mode 100644
index 000000000..df7fb6861
--- /dev/null
+++ b/src/contrib/service/consensus/test_consensus.conf
@@ -0,0 +1,87 @@
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-consensus/
+
+[consensus]
+#OPTIONS = -L INFO
+BINARY = gnunet-service-consensus
+
+#PREFIX = valgrind
+
+#EVIL_SPEC = 0;cram-all;noreplace;5
+#EVIL_SPEC = 0;cram;5/1;cram;5
+#EVIL_SPEC = 0;cram;5/1;cram;5/2;cram;5
+#EVIL_SPEC = 0;cram;5/1;cram;5/2;cram;5/3;cram;5
+
+
+[arm]
+RESOURCE_DIAGNOSTICS = resource.log.${PEERID:-master}
+
+[core]
+IMMEDIATE_START = YES
+
+[revocation]
+IMMEDIATE_START = NO
+
+[fs]
+IMMEDIATE_START = NO
+
+[gns]
+IMMEDIATE_START = NO
+
+[zonemaster]
+IMMEDIATE_START = NO
+
+[hostlist]
+IMMEDIATE_START = NO
+
+[cadet]
+#PREFIX = valgrind
+
+[transport]
+PLUGINS = unix
+OPTIONS = -LERROR
+
+[set]
+#OPTIONS = -L INFO
+#PREFIX = valgrind --leak-check=full
+#PREFIX = valgrind
+
+[testbed]
+OVERLAY_TOPOLOGY = CLIQUE
+MAX_PARALLEL_OPERATIONS = 1000
+MAX_PARALLEL_TOPOLOGY_CONFIG_OPERATIONS = 100
+OPERATION_TIMEOUT = 60 s
+MAX_OPEN_FDS = 4096
+
+[hostlist]
+START_ON_DEMAND = NO
+
+[fs]
+START_ON_DEMAND = NO
+
+[revocation]
+START_ON_DEMAND = NO
+
+[nat]
+# Use addresses from the local network interfaces (including loopback, but also others)
+USE_LOCALADDR = YES
+
+# Disable IPv6 support
+DISABLEV6 = NO
+
+# Do we use addresses from localhost address ranges? (::1, 127.0.0.0/8)
+RETURN_LOCAL_ADDRESSES = YES
+
+[nse]
+WORKBITS=0
+
+[ats]
+WAN_QUOTA_IN = unlimited
+WAN_QUOTA_OUT = unlimited
+
+[core]
+USE_EPHEMERAL_KEYS = NO
+
+[rps]
+START_ON_DEMAND = NO
+IMMEDIATE_START = NO
diff --git a/src/contrib/service/consensus/test_consensus_api.c b/src/contrib/service/consensus/test_consensus_api.c
new file mode 100644
index 000000000..235a67484
--- /dev/null
+++ b/src/contrib/service/consensus/test_consensus_api.c
@@ -0,0 +1,120 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2012 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file consensus/test_consensus_api.c
+ * @brief testcase for consensus_api.c
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_consensus_service.h"
+#include "gnunet_testing_lib.h"
+
+
+static struct GNUNET_CONSENSUS_Handle *consensus;
+
+static struct GNUNET_HashCode session_id;
+
+static unsigned int elements_received;
+
+
+static void
+conclude_done (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "conclude over\n");
+  if (2 != elements_received)
+    GNUNET_assert (0);
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+static void
+on_new_element (void *cls,
+                const struct GNUNET_SET_Element *element)
+{
+  elements_received++;
+}
+
+
+static void
+insert_done (void *cls, int success)
+{
+  /* make sure cb is only called once */
+  static int called = GNUNET_NO;
+
+  GNUNET_assert (GNUNET_NO == called);
+  called = GNUNET_YES;
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "insert done\n");
+  GNUNET_CONSENSUS_conclude (consensus, &conclude_done, NULL);
+}
+
+
+/**
+ * Signature of the main function of a task.
+ *
+ * @param cls closure
+ */
+static void
+on_shutdown (void *cls)
+{
+  if (NULL != consensus)
+  {
+    GNUNET_CONSENSUS_destroy (consensus);
+    consensus = NULL;
+  }
+}
+
+
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
+{
+  char *str = "foo";
+
+  struct GNUNET_SET_Element el1 = { 4, 0, "foo" };
+  struct GNUNET_SET_Element el2 = { 5, 0, "quux" };
+
+  GNUNET_log_setup ("test_consensus_api",
+                    "INFO",
+                    NULL);
+  GNUNET_SCHEDULER_add_shutdown (&on_shutdown, NULL);
+
+  GNUNET_CRYPTO_hash (str, strlen (str), &session_id);
+  consensus = GNUNET_CONSENSUS_create (cfg, 0, NULL, &session_id,
+                                       GNUNET_TIME_relative_to_absolute (
+                                         GNUNET_TIME_UNIT_SECONDS),
+                                       GNUNET_TIME_relative_to_absolute (
+                                         GNUNET_TIME_UNIT_MINUTES),
+                                       on_new_element, &consensus);
+  GNUNET_assert (consensus != NULL);
+
+  GNUNET_CONSENSUS_insert (consensus, &el1, NULL, &consensus);
+  GNUNET_CONSENSUS_insert (consensus, &el2, &insert_done, &consensus);
+}
+
+
+int
+main (int argc, char **argv)
+{
+  return GNUNET_TESTING_peer_run ("test_consensus_api",
+                                  "test_consensus.conf",
+                                  &run, NULL);
+}
diff --git a/src/contrib/service/conversation/.gitignore b/src/contrib/service/conversation/.gitignore
new file mode 100644
index 000000000..e74e259bf
--- /dev/null
+++ b/src/contrib/service/conversation/.gitignore
@@ -0,0 +1,8 @@
+gnunet-service-conversation
+gnunet-conversation
+gnunet-conversation-test
+gnunet-helper-audio-playback
+gnunet-helper-audio-record
+test_conversation_api
+test_conversation_api_reject
+test_conversation_api_twocalls
diff --git a/src/contrib/service/conversation/Makefile.am b/src/contrib/service/conversation/Makefile.am
new file mode 100644
index 000000000..b573208e6
--- /dev/null
+++ b/src/contrib/service/conversation/Makefile.am
@@ -0,0 +1,263 @@
+# This Makefile.am is in the public domain
+SUBDIRS = .
+
+plugindir = $(libdir)/gnunet
+
+AM_CPPFLAGS = \
+  $(GNUNET_CPPFLAGS) \
+  -I$(top_srcdir)/src/include \
+  -I$(top_srcdir)
+
+
+if BUILD_CONVERSATION
+lib_LTLIBRARIES = \
+ libgnunetmicrophone.la \
+ libgnunetspeaker.la \
+ libgnunetconversation.la
+
+bin_PROGRAMS = \
+ gnunet-conversation-test \
+ gnunet-conversation
+
+libexec_PROGRAMS = \
+  gnunet-service-conversation
+
+check_PROGRAMS = \
+ test_conversation_api \
+ test_conversation_api_reject \
+ test_conversation_api_twocalls
+
+pkgcfg_DATA = conversation.conf
+endif
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+plugin_LTLIBRARIES = \
+  libgnunet_plugin_gnsrecord_conversation.la
+
+
+libgnunet_plugin_gnsrecord_conversation_la_SOURCES = \
+  plugin_gnsrecord_conversation.c
+libgnunet_plugin_gnsrecord_conversation_la_LIBADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunet_plugin_gnsrecord_conversation_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
+
+
+libgnunetmicrophone_la_SOURCES = \
+  microphone.c
+libgnunetmicrophone_la_LIBADD = \
+ $(top_builddir)/src/lib/util/libgnunetutil.la
+libgnunetmicrophone_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)   \
+  -version-info 0:0:0
+
+libgnunetspeaker_la_SOURCES = \
+  speaker.c
+libgnunetspeaker_la_LIBADD = \
+ $(top_builddir)/src/lib/util/libgnunetutil.la
+libgnunetspeaker_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)   \
+  -version-info 0:0:0
+
+
+libgnunetconversation_la_SOURCES = \
+  conversation_api.c \
+  conversation_api_call.c \
+  conversation.h
+libgnunetconversation_la_LIBADD = \
+  $(top_builddir)/src/service/gns/libgnunetgns.la \
+  $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la \
+  $(top_builddir)/src/service/namestore/libgnunetnamestore.la \
+  $(top_builddir)/src/service/identity/libgnunetidentity.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
+
+libgnunetconversation_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)   \
+  -version-info 0:0:0
+
+
+if BUILD_PULSE_HELPERS
+AUDIO_HELPER_RECD=gnunet-helper-audio-record
+AUDIO_HELPER_PLAY=gnunet-helper-audio-playback
+AUDIO_TESTS=$(check_PROGRAMS)
+else
+if BUILD_GST_HELPERS
+AUDIO_HELPER_RECD=gnunet-helper-audio-record
+AUDIO_HELPER_PLAY=gnunet-helper-audio-playback
+AUDIO_TESTS=$(check_PROGRAMS)
+else
+if BUILD_EXPERIMENTAL_HELPERS
+AUDIO_HELPER_RECD=gnunet-helper-audio-record
+AUDIO_HELPER_PLAY=gnunet-helper-audio-playback
+AUDIO_TESTS=$(check_PROGRAMS)
+endif
+endif
+endif
+
+if BUILD_CONVERSATION
+libexec_PROGRAMS += \
+  $(AUDIO_HELPER_RECD) \
+  $(AUDIO_HELPER_PLAY)
+endif
+
+AM_TESTS_ENVIRONMENT=export GNUNET_PREFIX=$${GNUNET_PREFIX:-@libdir@};export PATH=$${GNUNET_PREFIX:-@prefix@}/bin:$$PATH;unset XDG_DATA_HOME;unset XDG_CONFIG_HOME;
+if ENABLE_TEST_RUN
+TESTS = $(AUDIO_TESTS)
+endif
+
+if BUILD_PULSE_HELPERS
+gnunet_helper_audio_record_SOURCES = \
+  gnunet-helper-audio-record.c
+gnunet_helper_audio_record_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  -lpulse  -lopus -logg \
+  $(INTLLIBS)
+#gnunet_helper_audio_record_LDFLAGS = \
+#  
+
+gnunet_helper_audio_playback_SOURCES = \
+  gnunet-helper-audio-playback.c
+gnunet_helper_audio_playback_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  -lpulse -lopus -logg \
+  $(INTLLIBS)
+#gnunet_helper_audio_playback_LDFLAGS = \
+#  
+else
+if BUILD_GST_HELPERS
+gnunet_helper_audio_record_SOURCES = \
+  gnunet-helper-audio-record-gst.c
+gnunet_helper_audio_record_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(GST_LIBS) \
+  $(INTLLIBS)
+gnunet_helper_audio_record_LDFLAGS = \
+   $(GST_LDFLAGS)
+gnunet_helper_audio_record_CFLAGS = \
+ $(GST_CFLAGS)
+
+gnunet_helper_audio_playback_SOURCES = \
+    gnunet-helper-audio-playback-gst.c
+gnunet_helper_audio_playback_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(GST_LIBS) \
+  $(INTLLIBS)
+gnunet_helper_audio_playback_LDFLAGS = \
+   $(GST_LDFLAGS)
+gnunet_helper_audio_playback_CFLAGS = \
+ $(GST_CFLAGS) -DIS_SPEAKER
+else
+if BUILD_EXPERIMENTAL_HELPERS
+gnunet_helper_audio_record_SOURCES = \
+  gnunet_gst_test.c gnunet_gst.c
+gnunet_helper_audio_record_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(GST_LIBS) \
+  $(INTLLIBS)
+gnunet_helper_audio_record_LDFLAGS = \
+   $(GST_LDFLAGS)
+gnunet_helper_audio_record_CFLAGS = \
+ $(GST_CFLAGS) -DIS_MIC
+
+gnunet_helper_audio_playback_SOURCES = \
+    gnunet_gst_test.c gnunet_gst.c
+gnunet_helper_audio_playback_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(GST_LIBS) \
+  $(INTLLIBS)
+gnunet_helper_audio_playback_LDFLAGS = \
+   $(GST_LDFLAGS)
+gnunet_helper_audio_playback_CFLAGS = \
+ $(GST_CFLAGS) -DIS_SPEAKER
+endif
+endif
+endif
+
+gnunet_service_conversation_SOURCES = \
+  gnunet-service-conversation.c
+gnunet_service_conversation_LDADD = \
+  libgnunetconversation.la \
+  libgnunetspeaker.la \
+  libgnunetmicrophone.la \
+  $(top_builddir)/src/service/cadet/libgnunetcadet.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/service/identity/libgnunetidentity.la \
+  $(INTLLIBS)
+#gnunet_service_conversation_LDFLAGS = \
+#  
+
+gnunet_conversation_SOURCES = \
+  gnunet-conversation.c
+gnunet_conversation_LDADD = \
+  libgnunetmicrophone.la \
+  libgnunetspeaker.la \
+  libgnunetconversation.la \
+  $(top_builddir)/src/service/gns/libgnunetgns.la \
+  $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la \
+  $(top_builddir)/src/service/namestore/libgnunetnamestore.la \
+  $(top_builddir)/src/service/identity/libgnunetidentity.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(INTLLIBS)
+#gnunet_conversation_LDFLAGS = \
+# 
+
+gnunet_conversation_test_SOURCES = \
+  gnunet-conversation-test.c
+gnunet_conversation_test_LDADD = \
+  libgnunetmicrophone.la \
+  libgnunetspeaker.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la  \
+  $(INTLLIBS)
+#gnunet_conversation_test_LDFLAGS = \
+# 
+
+
+test_conversation_api_SOURCES = \
+ test_conversation_api.c
+test_conversation_api_LDADD = \
+  libgnunetconversation.la \
+  libgnunetspeaker.la \
+  libgnunetmicrophone.la \
+  $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la \
+  $(top_builddir)/src/service/namestore/libgnunetnamestore.la \
+  $(top_builddir)/src/service/identity/libgnunetidentity.la \
+  $(top_builddir)/src/service/testing/libgnunettesting.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
+test_conversation_api_LDFLAGS = \
+  -export-dynamic
+
+test_conversation_api_twocalls_SOURCES = \
+ test_conversation_api_twocalls.c
+test_conversation_api_twocalls_LDADD = \
+  libgnunetconversation.la \
+  libgnunetspeaker.la \
+  libgnunetmicrophone.la \
+  $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la \
+  $(top_builddir)/src/service/namestore/libgnunetnamestore.la \
+  $(top_builddir)/src/service/identity/libgnunetidentity.la \
+  $(top_builddir)/src/service/testing/libgnunettesting.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
+test_conversation_api_twocalls_LDFLAGS = \
+  -export-dynamic
+
+test_conversation_api_reject_SOURCES = \
+ test_conversation_api_reject.c
+test_conversation_api_reject_LDADD = \
+  libgnunetconversation.la \
+  libgnunetspeaker.la \
+  libgnunetmicrophone.la \
+  $(top_builddir)/src/lib/gnsrecord/libgnunetgnsrecord.la \
+  $(top_builddir)/src/service/namestore/libgnunetnamestore.la \
+  $(top_builddir)/src/service/identity/libgnunetidentity.la \
+  $(top_builddir)/src/service/testing/libgnunettesting.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
+test_conversation_api_reject_LDFLAGS = \
+  -export-dynamic
+
+
+
+EXTRA_DIST = test_conversation.conf
diff --git a/src/contrib/service/conversation/build_gst_test.sh b/src/contrib/service/conversation/build_gst_test.sh
new file mode 100644
index 000000000..1feb9e1c4
--- /dev/null
+++ b/src/contrib/service/conversation/build_gst_test.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+colorgcc  -DIS_MIC -g gnunet_gst_test.c gnunet_gst.c -o gnunet-helper-audio-record-experimental `pkg-config --cflags --libs gstreamer-app-1.0 gnunetutil gnunetconversation gnunetenv  gstreamer-app-1.0 gstreamer-1.0 gstreamer-audio-1.0 gstreamer-pbutils-1.0 gstreamer-video-1.0` -O0 -march=native  -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-conversion  -Wformat -Wformat-security -fstack-protector -D_FORTIFY_SOURCE=2 -std=c99  -D_GNU_SOURCE
+
+colorgcc -DIS_SPEAKER -g gnunet_gst_test.c gnunet_gst.c -o gnunet-helper-audio-playback-experimental `pkg-config --cflags --libs gstreamer-app-1.0 gnunetutil gnunetconversation gnunetenv  gstreamer-app-1.0 gstreamer-1.0 gstreamer-audio-1.0 gstreamer-pbutils-1.0 gstreamer-video-1.0` -O0 -march=native  -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-conversion  -Wformat -Wformat-security -fstack-protector -D_FORTIFY_SOURCE=2 -std=c99  -D_GNU_SOURCE
+
+
+
+#colorgcc  -g gnunet_gst_test.c gnunet_gst.c -o gnunet_gst_test `pkg-config --cflags --libs  gstreamer-app-1.0 gstreamer-1.0 gstreamer-audio-1.0 gstreamer-pbutils-1.0 gstreamer-video-1.0` -O0 -march=native -Wall -Wextra -Wno-unused-parameter -Wno-unused-variable -Wno-unused-function -Wno-conversion -Wpedantic -Wformat -Wformat-security -fstack-protector -D_FORTIFY_SOURCE=2 -std=c99  -D_GNU_SOURCE
diff --git a/src/contrib/service/conversation/conversation.conf.in b/src/contrib/service/conversation/conversation.conf.in
new file mode 100644
index 000000000..b28fb6e1f
--- /dev/null
+++ b/src/contrib/service/conversation/conversation.conf.in
@@ -0,0 +1,29 @@
+[conversation]
+START_ON_DEMAND = @START_ON_DEMAND@
+BINARY = gnunet-service-conversation
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-conversation.sock
+HOSTNAME = localhost
+@UNIXONLY@ PORT = 2120
+
+# Desired phone line.  Change if multiple users are using
+# the same peer and we thus need disjoint phone lines.
+LINE = 1
+
+# Should the phone record be private? (only set to YES if
+# you really know what you are doing, you will then likely
+# not be able to receive calls).
+RECORD_IS_PRIVATE = NO
+
+# How long should phone records remain published in GNS?
+# A long expiration time has the advantage that the phone
+# is more likely found and/or resolved faster, OTOH it
+# then takes longer to change the phone line if necessary.
+# The default should be fine for most users.
+RECORD_EXPIRATION = 1 day
+
+
+ACCEPT_FROM = 127.0.0.1;
+ACCEPT_FROM6 = ::1;
+UNIX_MATCH_UID = NO
+UNIX_MATCH_GID = YES
+
diff --git a/src/contrib/service/conversation/conversation.h b/src/contrib/service/conversation/conversation.h
new file mode 100644
index 000000000..ee4ca372c
--- /dev/null
+++ b/src/contrib/service/conversation/conversation.h
@@ -0,0 +1,407 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 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 conversation/conversation.h
+ * @brief constants for network protocols
+ * @author Siomon Dieterle
+ * @author Andreas Fuchs
+ */
+#ifndef CONVERSATION_H
+#define CONVERSATION_H
+
+#include "gnunet_identity_service.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+
+#define MAX_TRANSMIT_DELAY GNUNET_TIME_relative_multiply ( \
+    GNUNET_TIME_UNIT_SECONDS, 60)
+
+
+/**
+ * Highest bit in a 32-bit unsigned integer,
+ * bit set if we are making an outgoing call,
+ * bit unset for local lines.
+ */
+#define HIGH_BIT ((uint32_t) (1LL << 31))
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+
+/**
+ * Message to transmit the audio (between client and helpers).
+ */
+struct AudioMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO
+   */
+  struct GNUNET_MessageHeader header;
+
+  /* followed by audio data */
+};
+
+
+/**
+ * Client -> Service message to register a phone.
+ */
+struct ClientPhoneRegisterMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_REGISTER
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Always zero.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * Phone line / CADET port to register.
+   */
+  struct GNUNET_HashCode line_port;
+};
+
+
+/**
+ * Service -> Client message for phone is ringing.
+ */
+struct ClientPhoneRingMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * CID, internal caller ID number used in the future to identify
+   * which active call we are talking about.
+   */
+  uint32_t cid GNUNET_PACKED;
+
+  /**
+   * The identity key length
+   */
+  uint32_t key_len;
+
+  /**
+   * followed by who is calling us?, a public key
+   */
+};
+
+
+/**
+ * Service <-> Client message for phone was suspended.
+ */
+struct ClientPhoneSuspendMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * CID, internal caller ID to identify which active call we are
+   * talking about.
+   */
+  uint32_t cid GNUNET_PACKED;
+};
+
+
+/**
+ * Service <-> Client message for phone was resumed.
+ */
+struct ClientPhoneResumeMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * CID, internal caller ID to identify which active call we are
+   * talking about.
+   */
+  uint32_t cid GNUNET_PACKED;
+};
+
+
+/**
+ * Client -> Service pick up phone that is ringing.
+ */
+struct ClientPhonePickupMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICK_UP
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * CID, internal caller ID to identify which active call we are
+   * talking about.
+   */
+  uint32_t cid GNUNET_PACKED;
+};
+
+
+/**
+ * Client <-> Service hang up phone that may or may not be ringing.
+ * Also sent in response to a (failed) `struct ClientCallMessage`.
+ */
+struct ClientPhoneHangupMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * CID, internal caller ID to identify which active call we are
+   * talking about.
+   */
+  uint32_t cid GNUNET_PACKED;
+};
+
+
+/**
+ * Message Client <-> Service to transmit the audio.
+ */
+struct ClientAudioMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * CID, internal caller ID to identify which active call we are
+   * sending data to.
+   */
+  uint32_t cid GNUNET_PACKED;
+
+  /* followed by audio data */
+};
+
+
+/**
+ * Client -> Service message to call a phone.
+ */
+struct ClientCallMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Always zero.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * Which peer is hosting the line?
+   */
+  struct GNUNET_PeerIdentity target;
+
+  /**
+   * Which phone line to call at the peer?
+   */
+  struct GNUNET_HashCode line_port;
+
+  /**
+   * The identity key length
+   */
+  uint32_t key_len;
+
+  /**
+   * followed by the identity of the caller.
+   */
+};
+
+
+/**
+ * Service -> Client: other peer has picked up the phone, we are
+ * now talking.
+ */
+struct ClientPhonePickedupMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Call ID of the corresponding
+   * #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL
+   */
+  uint32_t cid GNUNET_PACKED;
+};
+
+
+/**
+ * Information signed in a `struct CadetPhoneRingMessage`
+ * whereby the caller self-identifies to the receiver.
+ */
+struct CadetPhoneRingInfoPS
+{
+  /**
+   * Purpose for the signature, must be
+   * #GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING.
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+
+  /**
+   * Which port did the call go to?
+   */
+  struct GNUNET_HashCode line_port;
+
+  /**
+   * Which peer is the call for?
+   */
+  struct GNUNET_PeerIdentity target_peer;
+
+  /**
+   * When does the signature expire?
+   */
+  struct GNUNET_TIME_AbsoluteNBO expiration_time;
+};
+
+
+/**
+ * Cadet message to make a phone ring.  Sent to the port
+ * of the respective phone.
+ */
+struct CadetPhoneRingMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RING
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Always zero.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * When does the signature expire?
+   */
+  struct GNUNET_TIME_AbsoluteNBO expiration_time;
+
+  /**
+   * The length of the key
+   */
+  uint32_t key_len;
+
+  /**
+   * The length of the signature
+   */
+  uint32_t sig_len;
+
+  /**
+   * Followed by the public key of who is calling us? (also who is signing).
+   * followed by the signature over a `struct CadetPhoneRingInfoPS`
+   */
+};
+
+
+/**
+ * Cadet message for hanging up.
+ */
+struct CadetPhoneHangupMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP
+   */
+  struct GNUNET_MessageHeader header;
+};
+
+
+/**
+ * Cadet message for picking up.
+ */
+struct CadetPhonePickupMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP
+   */
+  struct GNUNET_MessageHeader header;
+};
+
+
+/**
+ * Cadet message for phone suspended.
+ */
+struct CadetPhoneSuspendMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND
+   */
+  struct GNUNET_MessageHeader header;
+};
+
+
+/**
+ * Cadet message for phone resumed.
+ */
+struct CadetPhoneResumeMessage
+{
+  /**
+   * Type is: #GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME
+   */
+  struct GNUNET_MessageHeader header;
+};
+
+
+/**
+ * Cadet message to transmit the audio.
+ */
+struct CadetAudioMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO
+   */
+  struct GNUNET_MessageHeader header;
+
+  /* followed by audio data */
+};
+
+
+GNUNET_NETWORK_STRUCT_END
+
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+/* ifndef GNUNET_PROTOCOLS_CONVERSATION_H */
+#endif
+/* end of gnunet_protocols_conversation.h */
diff --git a/src/contrib/service/conversation/conversation_api.c b/src/contrib/service/conversation/conversation_api.c
new file mode 100644
index 000000000..ed22bf9cf
--- /dev/null
+++ b/src/contrib/service/conversation/conversation_api.c
@@ -0,0 +1,897 @@
+/*
+   This file is part of GNUnet
+   Copyright (C) 2013, 2014 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 conversation/conversation_api.c
+ * @brief phone and caller API to the conversation service
+ * @author Simon Dieterle
+ * @author Andreas Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_conversation_service.h"
+#include "conversation.h"
+
+
+/**
+ * Possible states of a caller.
+ */
+enum CallerState
+{
+  /**
+   * The phone is ringing (user knows about incoming call).
+   */
+  CS_RINGING,
+
+  /**
+   * The phone is in an active conversation.
+   */
+  CS_ACTIVE,
+
+  /**
+   * We suspended the conversation.
+   */
+  CS_CALLEE_SUSPENDED,
+
+  /**
+   * Caller suspended the conversation.
+   */
+  CS_CALLER_SUSPENDED,
+
+  /**
+   * Both sides suspended the conversation.
+   */
+  CS_BOTH_SUSPENDED
+};
+
+
+/**
+ * A caller is the handle we have for an incoming call.
+ */
+struct GNUNET_CONVERSATION_Caller
+{
+  /**
+   * We keep all callers in a DLL.
+   */
+  struct GNUNET_CONVERSATION_Caller *next;
+
+  /**
+   * We keep all callers in a DLL.
+   */
+  struct GNUNET_CONVERSATION_Caller *prev;
+
+  /**
+   * Our phone.
+   */
+  struct GNUNET_CONVERSATION_Phone *phone;
+
+  /**
+   * Function to call for phone events.
+   */
+  GNUNET_CONVERSATION_CallerEventHandler event_handler;
+
+  /**
+   * Closure for @e event_handler
+   */
+  void *event_handler_cls;
+
+  /**
+   * Speaker, or NULL if none is attached.
+   */
+  struct GNUNET_SPEAKER_Handle *speaker;
+
+  /**
+   * Microphone, or NULL if none is attached.
+   */
+  struct GNUNET_MICROPHONE_Handle *mic;
+
+  /**
+   * Identity of the person calling us.
+   */
+  struct GNUNET_CRYPTO_PublicKey caller_id;
+
+  /**
+   * Internal handle to identify the caller with the service.
+   */
+  uint32_t cid;
+
+  /**
+   * State machine for the phone.
+   */
+  enum CallerState state;
+};
+
+
+/**
+ * Possible states of a phone.
+ */
+enum PhoneState
+{
+  /**
+   * We still need to register the phone.
+   */
+  PS_REGISTER = 0,
+
+  /**
+   * We are waiting for calls.
+   */
+  PS_READY
+};
+
+
+/**
+ * A phone is a device that can ring to signal an incoming call and
+ * that you can pick up to answer the call and hang up to terminate
+ * the call.  You can also hang up a ringing phone immediately
+ * (without picking it up) to stop it from ringing.  Phones have
+ * caller ID.  You can ask the phone for its record and make that
+ * record available (via GNS) to enable others to call you.
+ * Multiple phones maybe connected to the same line (the line is
+ * something rather internal to a phone and not obvious from it).
+ * You can only have one conversation per phone at any time.
+ */
+struct GNUNET_CONVERSATION_Phone
+{
+  /**
+   * Our configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * We keep all callers in a DLL.
+   */
+  struct GNUNET_CONVERSATION_Caller *caller_head;
+
+  /**
+   * We keep all callers in a DLL.
+   */
+  struct GNUNET_CONVERSATION_Caller *caller_tail;
+
+  /**
+   * Function to call for phone events.
+   */
+  GNUNET_CONVERSATION_PhoneEventHandler event_handler;
+
+  /**
+   * Closure for @e event_handler
+   */
+  void *event_handler_cls;
+
+  /**
+   * Connection to NAMESTORE (for reverse lookup).
+   */
+  struct GNUNET_NAMESTORE_Handle *ns;
+
+  /**
+   * Handle for transmitting to the CONVERSATION service.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * This phone's record.
+   */
+  struct GNUNET_CONVERSATION_PhoneRecord my_record;
+
+  /**
+   * My GNS zone.
+   */
+  struct GNUNET_CRYPTO_PrivateKey my_zone;
+
+  /**
+   * State machine for the phone.
+   */
+  enum PhoneState state;
+};
+
+
+/**
+ * The phone got disconnected, reconnect to the service.
+ *
+ * @param phone phone to reconnect
+ */
+static void
+reconnect_phone (struct GNUNET_CONVERSATION_Phone *phone);
+
+
+/**
+ * Process recorded audio data.
+ *
+ * @param cls closure with the `struct GNUNET_CONVERSATION_Caller`
+ * @param data_size number of bytes in @a data
+ * @param data audio data to play
+ */
+static void
+transmit_phone_audio (void *cls,
+                      size_t data_size,
+                      const void *data)
+{
+  struct GNUNET_CONVERSATION_Caller *caller = cls;
+  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientAudioMessage *am;
+
+  e = GNUNET_MQ_msg_extra (am,
+                           data_size,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO);
+  am->cid = caller->cid;
+  GNUNET_memcpy (&am[1],
+                 data,
+                 data_size);
+  GNUNET_MQ_send (phone->mq,
+                  e);
+}
+
+/**
+ * We received a `struct ClientPhoneRingMessage`
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param ring the message
+ */
+static enum GNUNET_GenericReturnValue
+check_phone_ring (void *cls,
+                   const struct ClientPhoneRingMessage *ring)
+{
+  //FIXME
+  return GNUNET_OK;
+}
+/**
+ * We received a `struct ClientPhoneRingMessage`
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param ring the message
+ */
+static void
+handle_phone_ring (void *cls,
+                   const struct ClientPhoneRingMessage *ring)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = cls;
+  struct GNUNET_CONVERSATION_Caller *caller;
+  struct GNUNET_CRYPTO_PublicKey caller_id;
+  size_t key_len;
+  size_t read;
+
+  key_len = ntohl (ring->key_len);
+  switch (phone->state)
+  {
+  case PS_REGISTER:
+    GNUNET_assert (0);
+    break;
+
+  case PS_READY:
+    if ((GNUNET_SYSERR ==
+         GNUNET_CRYPTO_read_public_key_from_buffer (&ring[1],
+                                                      key_len,
+                                                      &caller_id,
+                                                      &read)) ||
+        (read != key_len))
+    {
+      GNUNET_break (0);
+      break;
+    }
+    caller = GNUNET_new (struct GNUNET_CONVERSATION_Caller);
+    caller->phone = phone;
+    GNUNET_CONTAINER_DLL_insert (phone->caller_head,
+                                 phone->caller_tail,
+                                 caller);
+    caller->caller_id = caller_id;
+    caller->cid = ring->cid;
+    caller->state = CS_RINGING;
+    phone->event_handler (phone->event_handler_cls,
+                          GNUNET_CONVERSATION_EC_PHONE_RING,
+                          caller,
+                          &caller->caller_id);
+    break;
+  }
+}
+
+
+/**
+ * Find the record of the caller matching the @a cid
+ *
+ * @param phone phone to search
+ * @param cid caller ID to search for (in NBO)
+ * @return NULL if @a cid was not found
+ */
+static struct GNUNET_CONVERSATION_Caller *
+find_caller (struct GNUNET_CONVERSATION_Phone *phone,
+             uint32_t cid)
+{
+  struct GNUNET_CONVERSATION_Caller *caller;
+
+  for (caller = phone->caller_head; NULL != caller; caller = caller->next)
+    if (cid == caller->cid)
+      return caller;
+  return NULL;
+}
+
+
+/**
+ * We received a `struct ClientPhoneHangupMessage`.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone *`
+ * @param hang the message
+ */
+static void
+handle_phone_hangup (void *cls,
+                     const struct ClientPhoneHangupMessage *hang)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = cls;
+  struct GNUNET_CONVERSATION_Caller *caller;
+
+  caller = find_caller (phone,
+                        hang->cid);
+  if (NULL == caller)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received HANG_UP message for unknown caller ID %u\n",
+                (unsigned int) hang->cid);
+    return;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received HANG_UP message, terminating call with `%s'\n",
+              GNUNET_GNSRECORD_pkey_to_zkey (&caller->caller_id));
+  switch (caller->state)
+  {
+  case CS_RINGING:
+    phone->event_handler (phone->event_handler_cls,
+                          GNUNET_CONVERSATION_EC_PHONE_HUNG_UP,
+                          caller,
+                          &caller->caller_id);
+    break;
+
+  case CS_ACTIVE:
+    caller->speaker->disable_speaker (caller->speaker->cls);
+    caller->mic->disable_microphone (caller->mic->cls);
+    phone->event_handler (phone->event_handler_cls,
+                          GNUNET_CONVERSATION_EC_PHONE_HUNG_UP,
+                          caller,
+                          &caller->caller_id);
+    break;
+
+  case CS_CALLEE_SUSPENDED:
+  case CS_CALLER_SUSPENDED:
+  case CS_BOTH_SUSPENDED:
+    phone->event_handler (phone->event_handler_cls,
+                          GNUNET_CONVERSATION_EC_PHONE_HUNG_UP,
+                          caller,
+                          &caller->caller_id);
+    break;
+  }
+  GNUNET_CONTAINER_DLL_remove (phone->caller_head,
+                               phone->caller_tail,
+                               caller);
+  GNUNET_free (caller);
+}
+
+
+/**
+ * We received a `struct ClientPhoneSuspendMessage`.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param suspend the message
+ */
+static void
+handle_phone_suspend (void *cls,
+                      const struct ClientPhoneSuspendMessage *suspend)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = cls;
+  struct GNUNET_CONVERSATION_Caller *caller;
+
+  caller = find_caller (phone,
+                        suspend->cid);
+  if (NULL == caller)
+    return;
+  switch (caller->state)
+  {
+  case CS_RINGING:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_ACTIVE:
+    caller->state = CS_CALLER_SUSPENDED;
+    caller->speaker->disable_speaker (caller->speaker->cls);
+    caller->mic->disable_microphone (caller->mic->cls);
+    caller->event_handler (caller->event_handler_cls,
+                           GNUNET_CONVERSATION_EC_CALLER_SUSPEND);
+    break;
+
+  case CS_CALLEE_SUSPENDED:
+    caller->state = CS_BOTH_SUSPENDED;
+    caller->event_handler (caller->event_handler_cls,
+                           GNUNET_CONVERSATION_EC_CALLER_SUSPEND);
+    break;
+
+  case CS_CALLER_SUSPENDED:
+  case CS_BOTH_SUSPENDED:
+    GNUNET_break_op (0);
+    break;
+  }
+}
+
+
+/**
+ * We received a `struct ClientPhoneResumeMessage`.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param resume the message
+ */
+static void
+handle_phone_resume (void *cls,
+                     const struct ClientPhoneResumeMessage *resume)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = cls;
+  struct GNUNET_CONVERSATION_Caller *caller;
+
+  caller = find_caller (phone,
+                        resume->cid);
+  if (NULL == caller)
+    return;
+  switch (caller->state)
+  {
+  case CS_RINGING:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_ACTIVE:
+  case CS_CALLEE_SUSPENDED:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_CALLER_SUSPENDED:
+    caller->state = CS_ACTIVE;
+    caller->speaker->enable_speaker (caller->speaker->cls);
+    caller->mic->enable_microphone (caller->mic->cls,
+                                    &transmit_phone_audio,
+                                    caller);
+    caller->event_handler (caller->event_handler_cls,
+                           GNUNET_CONVERSATION_EC_CALLER_RESUME);
+    break;
+
+  case CS_BOTH_SUSPENDED:
+    caller->state = CS_CALLEE_SUSPENDED;
+    caller->event_handler (caller->event_handler_cls,
+                           GNUNET_CONVERSATION_EC_CALLER_RESUME);
+    break;
+  }
+}
+
+
+/**
+ * We received a `struct ClientAudioMessage`, check it is well-formed.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param am the message
+ * @return #GNUNET_OK if @a am is well-formed
+ */
+static int
+check_phone_audio (void *cls,
+                   const struct ClientAudioMessage *am)
+{
+  (void) cls;
+  (void) am;
+
+  /* any variable-size payload is OK */
+  return GNUNET_OK;
+}
+
+
+/**
+ * We received a `struct ClientAudioMessage`
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param am the message
+ */
+static void
+handle_phone_audio (void *cls,
+                    const struct ClientAudioMessage *am)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = cls;
+  struct GNUNET_CONVERSATION_Caller *caller;
+
+  caller = find_caller (phone,
+                        am->cid);
+  if (NULL == caller)
+    return;
+  switch (caller->state)
+  {
+  case CS_RINGING:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_ACTIVE:
+    caller->speaker->play (caller->speaker->cls,
+                           ntohs (am->header.size) - sizeof(struct
+                                                            ClientAudioMessage),
+                           &am[1]);
+    break;
+
+  case CS_CALLEE_SUSPENDED:
+  case CS_CALLER_SUSPENDED:
+  case CS_BOTH_SUSPENDED:
+    break;
+  }
+}
+
+
+/**
+ * We encountered an error talking with the conversation service.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Phone`
+ * @param error details about the error
+ */
+static void
+phone_error_handler (void *cls,
+                     enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = cls;
+
+  (void) error;
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              _ (
+                "Connection to conversation service lost, trying to reconnect\n"));
+  reconnect_phone (phone);
+}
+
+
+/**
+ * Clean up all callers of the given phone.
+ *
+ * @param phone phone to clean up callers for
+ */
+static void
+clean_up_callers (struct GNUNET_CONVERSATION_Phone *phone)
+{
+  struct GNUNET_CONVERSATION_Caller *caller;
+
+  while (NULL != (caller = phone->caller_head))
+  {
+    /* make sure mic/speaker are disabled *before* callback */
+    if (CS_ACTIVE == caller->state)
+    {
+      caller->speaker->disable_speaker (caller->speaker->cls);
+      caller->mic->disable_microphone (caller->mic->cls);
+      caller->state = CS_CALLER_SUSPENDED;
+    }
+    phone->event_handler (phone->event_handler_cls,
+                          GNUNET_CONVERSATION_EC_PHONE_HUNG_UP,
+                          caller,
+                          &caller->caller_id);
+    GNUNET_CONVERSATION_caller_hang_up (caller);
+  }
+}
+
+
+/**
+ * The phone got disconnected, reconnect to the service.
+ *
+ * @param phone phone to reconnect
+ */
+static void
+reconnect_phone (struct GNUNET_CONVERSATION_Phone *phone)
+{
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_var_size (phone_ring,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING,
+                           struct ClientPhoneRingMessage,
+                           phone),
+    GNUNET_MQ_hd_fixed_size (phone_hangup,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP,
+                             struct ClientPhoneHangupMessage,
+                             phone),
+    GNUNET_MQ_hd_fixed_size (phone_suspend,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND,
+                             struct ClientPhoneSuspendMessage,
+                             phone),
+    GNUNET_MQ_hd_fixed_size (phone_resume,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME,
+                             struct ClientPhoneResumeMessage,
+                             phone),
+    GNUNET_MQ_hd_var_size (phone_audio,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO,
+                           struct ClientAudioMessage,
+                           phone),
+    GNUNET_MQ_handler_end ()
+  };
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientPhoneRegisterMessage *reg;
+
+  clean_up_callers (phone);
+  if (NULL != phone->mq)
+  {
+    GNUNET_MQ_destroy (phone->mq);
+    phone->mq = NULL;
+  }
+  phone->state = PS_REGISTER;
+  phone->mq = GNUNET_CLIENT_connect (phone->cfg,
+                                     "conversation",
+                                     handlers,
+                                     &phone_error_handler,
+                                     phone);
+  if (NULL == phone->mq)
+    return;
+  e = GNUNET_MQ_msg (reg,
+                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_REGISTER);
+  reg->line_port = phone->my_record.line_port;
+  GNUNET_MQ_send (phone->mq,
+                  e);
+  phone->state = PS_READY;
+}
+
+
+/**
+ * Create a new phone.
+ *
+ * @param cfg configuration for the phone; specifies the phone service and
+ *        which line the phone is to be connected to
+ * @param ego ego to use for name resolution (when determining caller ID)
+ * @param event_handler how to notify the owner of the phone about events
+ * @param event_handler_cls closure for @a event_handler
+ * @return NULL on error (no valid line configured)
+ */
+struct GNUNET_CONVERSATION_Phone *
+GNUNET_CONVERSATION_phone_create (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                                  const struct GNUNET_IDENTITY_Ego *ego,
+                                  GNUNET_CONVERSATION_PhoneEventHandler
+                                  event_handler,
+                                  void *event_handler_cls)
+{
+  struct GNUNET_CONVERSATION_Phone *phone;
+  char *line;
+  struct GNUNET_HashCode line_port;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             "CONVERSATION",
+                                             "LINE",
+                                             &line))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               "CONVERSATION",
+                               "LINE");
+    return NULL;
+  }
+  GNUNET_CRYPTO_hash (line,
+                      strlen (line),
+                      &line_port);
+  GNUNET_free (line);
+  phone = GNUNET_new (struct GNUNET_CONVERSATION_Phone);
+  if (GNUNET_OK !=
+      GNUNET_CRYPTO_get_peer_identity (cfg,
+                                       &phone->my_record.peer))
+  {
+    GNUNET_break (0);
+    GNUNET_free (phone);
+    return NULL;
+  }
+  phone->cfg = cfg;
+  phone->my_zone = *GNUNET_IDENTITY_ego_get_private_key (ego);
+  phone->event_handler = event_handler;
+  phone->event_handler_cls = event_handler_cls;
+  phone->ns = GNUNET_NAMESTORE_connect (cfg);
+  phone->my_record.version = htonl (1);
+  phone->my_record.reserved = htonl (0);
+  phone->my_record.line_port = line_port;
+  reconnect_phone (phone);
+  if ((NULL == phone->mq) ||
+      (NULL == phone->ns))
+  {
+    GNUNET_break (0);
+    GNUNET_CONVERSATION_phone_destroy (phone);
+    return NULL;
+  }
+  return phone;
+}
+
+
+/**
+ * Fill in a namestore record with the contact information
+ * for this phone.  Note that the filled in "data" value
+ * is only valid until the phone is destroyed.
+ *
+ * @param phone phone to create a record for
+ * @param rd namestore record to fill in
+ */
+void
+GNUNET_CONVERSATION_phone_get_record (struct GNUNET_CONVERSATION_Phone *phone,
+                                      struct GNUNET_GNSRECORD_Data *rd)
+{
+  rd->data = &phone->my_record;
+  rd->expiration_time = 0;
+  rd->data_size = sizeof(struct GNUNET_CONVERSATION_PhoneRecord);
+  rd->record_type = GNUNET_GNSRECORD_TYPE_PHONE;
+  rd->flags = GNUNET_GNSRECORD_RF_NONE;
+}
+
+
+/**
+ * Picks up a (ringing) phone.  This will connect the speaker
+ * to the microphone of the other party, and vice versa.
+ *
+ * @param caller handle that identifies which caller should be answered
+ * @param event_handler how to notify about events by the caller
+ * @param event_handler_cls closure for @a event_handler
+ * @param speaker speaker to use
+ * @param mic microphone to use
+ */
+void
+GNUNET_CONVERSATION_caller_pick_up (struct GNUNET_CONVERSATION_Caller *caller,
+                                    GNUNET_CONVERSATION_CallerEventHandler
+                                    event_handler,
+                                    void *event_handler_cls,
+                                    struct GNUNET_SPEAKER_Handle *speaker,
+                                    struct GNUNET_MICROPHONE_Handle *mic)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientPhonePickupMessage *pick;
+
+  GNUNET_assert (CS_RINGING == caller->state);
+  caller->speaker = speaker;
+  caller->mic = mic;
+  e = GNUNET_MQ_msg (pick,
+                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICK_UP);
+  pick->cid = caller->cid;
+  GNUNET_MQ_send (phone->mq,
+                  e);
+  caller->state = CS_ACTIVE;
+  caller->event_handler = event_handler;
+  caller->event_handler_cls = event_handler_cls;
+  caller->speaker->enable_speaker (caller->speaker->cls);
+  caller->mic->enable_microphone (caller->mic->cls,
+                                  &transmit_phone_audio,
+                                  caller);
+}
+
+
+/**
+ * Hang up up a (possibly ringing) phone.  This will notify the other
+ * party that we are no longer interested in talking with them.
+ *
+ * @param caller conversation to hang up on
+ */
+void
+GNUNET_CONVERSATION_caller_hang_up (struct GNUNET_CONVERSATION_Caller *caller)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientPhoneHangupMessage *hang;
+
+  switch (caller->state)
+  {
+  case CS_ACTIVE:
+    caller->speaker->disable_speaker (caller->speaker->cls);
+    caller->mic->disable_microphone (caller->mic->cls);
+    break;
+
+  default:
+    break;
+  }
+  GNUNET_CONTAINER_DLL_remove (phone->caller_head,
+                               phone->caller_tail,
+                               caller);
+  e = GNUNET_MQ_msg (hang,
+                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP);
+  hang->cid = caller->cid;
+  GNUNET_MQ_send (phone->mq,
+                  e);
+  GNUNET_free (caller);
+}
+
+
+/**
+ * Destroys a phone.
+ *
+ * @param phone phone to destroy
+ */
+void
+GNUNET_CONVERSATION_phone_destroy (struct GNUNET_CONVERSATION_Phone *phone)
+{
+  clean_up_callers (phone);
+  if (NULL != phone->ns)
+  {
+    GNUNET_NAMESTORE_disconnect (phone->ns);
+    phone->ns = NULL;
+  }
+  if (NULL != phone->mq)
+  {
+    GNUNET_MQ_destroy (phone->mq);
+    phone->mq = NULL;
+  }
+  GNUNET_free (phone);
+}
+
+
+/**
+ * Pause conversation of an active call.  This will disconnect the speaker
+ * and the microphone.  The call can later be resumed with
+ * #GNUNET_CONVERSATION_caller_resume.
+ *
+ * @param caller call to suspend
+ */
+void
+GNUNET_CONVERSATION_caller_suspend (struct GNUNET_CONVERSATION_Caller *caller)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientPhoneSuspendMessage *suspend;
+
+  GNUNET_assert ((CS_ACTIVE == caller->state) ||
+                 (CS_CALLER_SUSPENDED == caller->state));
+  if (CS_ACTIVE == caller->state)
+  {
+    caller->speaker->disable_speaker (caller->speaker->cls);
+    caller->mic->disable_microphone (caller->mic->cls);
+  }
+  caller->speaker = NULL;
+  caller->mic = NULL;
+  e = GNUNET_MQ_msg (suspend,
+                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND);
+  suspend->cid = caller->cid;
+  GNUNET_MQ_send (phone->mq,
+                  e);
+  if (CS_ACTIVE == caller->state)
+    caller->state = CS_CALLEE_SUSPENDED;
+  else
+    caller->state = CS_BOTH_SUSPENDED;
+}
+
+
+/**
+ * Resume suspended conversation of a phone.
+ *
+ * @param caller call to resume
+ * @param speaker speaker to use
+ * @param mic microphone to use
+ */
+void
+GNUNET_CONVERSATION_caller_resume (struct GNUNET_CONVERSATION_Caller *caller,
+                                   struct GNUNET_SPEAKER_Handle *speaker,
+                                   struct GNUNET_MICROPHONE_Handle *mic)
+{
+  struct GNUNET_CONVERSATION_Phone *phone = caller->phone;
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientPhoneResumeMessage *resume;
+
+  GNUNET_assert ((CS_CALLEE_SUSPENDED == caller->state) ||
+                 (CS_BOTH_SUSPENDED == caller->state));
+  caller->speaker = speaker;
+  caller->mic = mic;
+  e = GNUNET_MQ_msg (resume,
+                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME);
+  resume->cid = caller->cid;
+  GNUNET_MQ_send (phone->mq,
+                  e);
+  if (CS_CALLEE_SUSPENDED == caller->state)
+  {
+    caller->state = CS_ACTIVE;
+    caller->speaker->enable_speaker (caller->speaker->cls);
+    caller->mic->enable_microphone (caller->mic->cls,
+                                    &transmit_phone_audio,
+                                    caller);
+  }
+  else
+  {
+    caller->state = CS_CALLER_SUSPENDED;
+  }
+}
+
+
+/* end of conversation_api.c */
diff --git a/src/contrib/service/conversation/conversation_api_call.c b/src/contrib/service/conversation/conversation_api_call.c
new file mode 100644
index 000000000..cd59678d9
--- /dev/null
+++ b/src/contrib/service/conversation/conversation_api_call.c
@@ -0,0 +1,749 @@
+/*
+   This file is part of GNUnet
+   Copyright (C) 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 conversation/conversation_api_call.c
+ * @brief call API to the conversation service
+ * @author Simon Dieterle
+ * @author Andreas Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_conversation_service.h"
+#include "gnunet_gnsrecord_lib.h"
+#include "gnunet_gns_service.h"
+#include "conversation.h"
+
+
+/**
+ * Possible states of the phone.
+ */
+enum CallState
+{
+  /**
+   * We still need to lookup the callee.
+   */
+  CS_LOOKUP = 0,
+
+  /**
+   * The call is ringing.
+   */
+  CS_RINGING,
+
+  /**
+   * The call is in an active conversation.
+   */
+  CS_ACTIVE,
+
+  /**
+   * The call is in termination.
+   */
+  CS_SHUTDOWN,
+
+  /**
+   * The call was suspended by the caller.
+   */
+  CS_SUSPENDED_CALLER,
+
+  /**
+   * The call was suspended by the callee.
+   */
+  CS_SUSPENDED_CALLEE,
+
+  /**
+   * The call was suspended by both caller and callee.
+   */
+  CS_SUSPENDED_BOTH
+};
+
+
+/**
+ * Handle for an outgoing call.
+ */
+struct GNUNET_CONVERSATION_Call
+{
+  /**
+   * Our configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Our caller identity.
+   */
+  struct GNUNET_IDENTITY_Ego *caller_id;
+
+  /**
+   * Target callee as a GNS address/name.
+   */
+  char *callee;
+
+  /**
+   * Our speaker.
+   */
+  struct GNUNET_SPEAKER_Handle *speaker;
+
+  /**
+   * Our microphone.
+   */
+  struct GNUNET_MICROPHONE_Handle *mic;
+
+  /**
+   * Function to call with events.
+   */
+  GNUNET_CONVERSATION_CallEventHandler event_handler;
+
+  /**
+   * Closure for @e event_handler
+   */
+  void *event_handler_cls;
+
+  /**
+   * Handle for transmitting to the CONVERSATION service.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Connection to GNS (can be NULL).
+   */
+  struct GNUNET_GNS_Handle *gns;
+
+  /**
+   * Active GNS lookup (or NULL).
+   */
+  struct GNUNET_GNS_LookupWithTldRequest *gns_lookup;
+
+  /**
+   * Target phone record, only valid after the lookup is done.
+   */
+  struct GNUNET_CONVERSATION_PhoneRecord phone_record;
+
+  /**
+   * State machine for the call.
+   */
+  enum CallState state;
+};
+
+
+/**
+ * The call got disconnected, reconnect to the service.
+ *
+ * @param call call to reconnect
+ */
+static void
+fail_call (struct GNUNET_CONVERSATION_Call *call);
+
+
+/**
+ * Process recorded audio data.
+ *
+ * @param cls closure with the `struct GNUNET_CONVERSATION_Call`
+ * @param data_size number of bytes in @a data
+ * @param data audio data to play
+ */
+static void
+transmit_call_audio (void *cls,
+                     size_t data_size,
+                     const void *data)
+{
+  struct GNUNET_CONVERSATION_Call *call = cls;
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientAudioMessage *am;
+
+  GNUNET_assert (CS_ACTIVE == call->state);
+  e = GNUNET_MQ_msg_extra (am,
+                           data_size,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO);
+  GNUNET_memcpy (&am[1],
+                 data,
+                 data_size);
+  GNUNET_MQ_send (call->mq,
+                  e);
+}
+
+
+/**
+ * We received a #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Call`
+ * @param msg the message
+ */
+static void
+handle_call_suspend (void *cls,
+                     const struct ClientPhoneSuspendMessage *msg)
+{
+  struct GNUNET_CONVERSATION_Call *call = cls;
+
+  (void) msg;
+  switch (call->state)
+  {
+  case CS_LOOKUP:
+    GNUNET_break (0);
+    fail_call (call);
+    break;
+
+  case CS_RINGING:
+    GNUNET_break_op (0);
+    fail_call (call);
+    break;
+
+  case CS_SUSPENDED_CALLER:
+    call->state = CS_SUSPENDED_BOTH;
+    call->event_handler (call->event_handler_cls,
+                         GNUNET_CONVERSATION_EC_CALL_SUSPENDED);
+    break;
+
+  case CS_SUSPENDED_CALLEE:
+  case CS_SUSPENDED_BOTH:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_ACTIVE:
+    call->state = CS_SUSPENDED_CALLEE;
+    call->speaker->disable_speaker (call->speaker->cls);
+    call->mic->disable_microphone (call->mic->cls);
+    call->event_handler (call->event_handler_cls,
+                         GNUNET_CONVERSATION_EC_CALL_SUSPENDED);
+    break;
+
+  case CS_SHUTDOWN:
+    GNUNET_CONVERSATION_call_stop (call);
+    break;
+  }
+}
+
+
+/**
+ * We received a #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Call`
+ * @param msg the message
+ */
+static void
+handle_call_resume (void *cls,
+                    const struct ClientPhoneResumeMessage *msg)
+{
+  struct GNUNET_CONVERSATION_Call *call = cls;
+
+  (void) msg;
+  switch (call->state)
+  {
+  case CS_LOOKUP:
+    GNUNET_break (0);
+    fail_call (call);
+    break;
+
+  case CS_RINGING:
+    GNUNET_break_op (0);
+    fail_call (call);
+    break;
+
+  case CS_SUSPENDED_CALLER:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_SUSPENDED_CALLEE:
+    call->state = CS_ACTIVE;
+    call->speaker->enable_speaker (call->speaker->cls);
+    call->mic->enable_microphone (call->mic->cls,
+                                  &transmit_call_audio,
+                                  call);
+    call->event_handler (call->event_handler_cls,
+                         GNUNET_CONVERSATION_EC_CALL_RESUMED);
+    break;
+
+  case CS_SUSPENDED_BOTH:
+    call->state = CS_SUSPENDED_CALLER;
+    call->event_handler (call->event_handler_cls,
+                         GNUNET_CONVERSATION_EC_CALL_RESUMED);
+    break;
+
+  case CS_ACTIVE:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_SHUTDOWN:
+    GNUNET_CONVERSATION_call_stop (call);
+    break;
+  }
+}
+
+
+/**
+ * We received a #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Call`
+ * @param msg the message
+ */
+static void
+handle_call_picked_up (void *cls,
+                       const struct ClientPhonePickedupMessage *msg)
+{
+  struct GNUNET_CONVERSATION_Call *call = cls;
+
+  (void) msg;
+  switch (call->state)
+  {
+  case CS_LOOKUP:
+    GNUNET_break (0);
+    fail_call (call);
+    break;
+
+  case CS_RINGING:
+    call->state = CS_ACTIVE;
+    call->speaker->enable_speaker (call->speaker->cls);
+    call->mic->enable_microphone (call->mic->cls,
+                                  &transmit_call_audio,
+                                  call);
+    call->event_handler (call->event_handler_cls,
+                         GNUNET_CONVERSATION_EC_CALL_PICKED_UP);
+    break;
+
+  case CS_SUSPENDED_CALLER:
+  case CS_SUSPENDED_CALLEE:
+  case CS_SUSPENDED_BOTH:
+  case CS_ACTIVE:
+    GNUNET_break (0);
+    fail_call (call);
+    break;
+
+  case CS_SHUTDOWN:
+    GNUNET_CONVERSATION_call_stop (call);
+    break;
+  }
+}
+
+
+/**
+ * We received a #GNUNET_MESSAGE_TYPE_CONVERSATION_CS_HANG_UP.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Call`
+ * @param msg the message
+ */
+static void
+handle_call_hangup (void *cls,
+                    const struct ClientPhoneHangupMessage *msg)
+{
+  struct GNUNET_CONVERSATION_Call *call = cls;
+  GNUNET_CONVERSATION_CallEventHandler eh;
+  void *eh_cls;
+
+  (void) msg;
+  switch (call->state)
+  {
+  case CS_LOOKUP:
+    GNUNET_break (0);
+    fail_call (call);
+    break;
+
+  case CS_RINGING:
+  case CS_SUSPENDED_CALLER:
+  case CS_SUSPENDED_CALLEE:
+  case CS_SUSPENDED_BOTH:
+  case CS_ACTIVE:
+    eh = call->event_handler;
+    eh_cls = call->event_handler_cls;
+    GNUNET_CONVERSATION_call_stop (call);
+    eh (eh_cls,
+        GNUNET_CONVERSATION_EC_CALL_HUNG_UP);
+    return;
+
+  case CS_SHUTDOWN:
+    GNUNET_CONVERSATION_call_stop (call);
+    break;
+  }
+}
+
+
+/**
+ * We received a `struct ClientAudioMessage`, check it is well-formed.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Call`
+ * @param am the message
+ * @return #GNUNET_OK (always well-formed)
+ */
+static int
+check_call_audio (void *cls,
+                  const struct ClientAudioMessage *am)
+{
+  (void) cls;
+  (void) am;
+  /* any payload is OK */
+  return GNUNET_OK;
+}
+
+
+/**
+ * We received a `struct ClientAudioMessage`
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Call`
+ * @param am the message
+ */
+static void
+handle_call_audio (void *cls,
+                   const struct ClientAudioMessage *am)
+{
+  struct GNUNET_CONVERSATION_Call *call = cls;
+
+  switch (call->state)
+  {
+  case CS_LOOKUP:
+    GNUNET_break (0);
+    fail_call (call);
+    break;
+
+  case CS_RINGING:
+    GNUNET_break (0);
+    fail_call (call);
+    break;
+
+  case CS_SUSPENDED_CALLER:
+    /* can happen: we suspended, other peer did not yet
+       learn about this. */
+    break;
+
+  case CS_SUSPENDED_CALLEE:
+  case CS_SUSPENDED_BOTH:
+    /* can (rarely) also happen: other peer suspended, but cadet might
+       have had delayed data on the unreliable channel */
+    break;
+
+  case CS_ACTIVE:
+    call->speaker->play (call->speaker->cls,
+                         ntohs (am->header.size) - sizeof(struct
+                                                          ClientAudioMessage),
+                         &am[1]);
+    break;
+
+  case CS_SHUTDOWN:
+    GNUNET_CONVERSATION_call_stop (call);
+    break;
+  }
+}
+
+
+/**
+ * Iterator called on obtained result for a GNS lookup.
+ *
+ * @param cls closure with the `struct GNUNET_CONVERSATION_Call`
+ * @param was_gns #GNUNET_NO if name was not a GNS name
+ * @param rd_count number of records in @a rd
+ * @param rd the records in reply
+ */
+static void
+handle_gns_response (void *cls,
+                     int was_gns,
+                     uint32_t rd_count,
+                     const struct GNUNET_GNSRECORD_Data *rd)
+{
+  struct GNUNET_CONVERSATION_Call *call = cls;
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientCallMessage *ccm;
+  const struct GNUNET_CRYPTO_PrivateKey *caller_id;
+  size_t key_len;
+
+  (void) was_gns;
+  GNUNET_break (NULL != call->gns_lookup);
+  GNUNET_break (CS_LOOKUP == call->state);
+  call->gns_lookup = NULL;
+  for (uint32_t i = 0; i < rd_count; i++)
+  {
+    if (GNUNET_GNSRECORD_TYPE_PHONE == rd[i].record_type)
+    {
+      if (rd[i].data_size != sizeof(struct GNUNET_CONVERSATION_PhoneRecord))
+      {
+        GNUNET_break_op (0);
+        continue;
+      }
+      GNUNET_memcpy (&call->phone_record,
+                     rd[i].data,
+                     rd[i].data_size);
+      caller_id = GNUNET_IDENTITY_ego_get_private_key (call->caller_id);
+      key_len = GNUNET_CRYPTO_private_key_get_length (caller_id);
+      e = GNUNET_MQ_msg_extra (ccm, key_len,
+                               GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL);
+      ccm->line_port = call->phone_record.line_port;
+      ccm->target = call->phone_record.peer;
+      GNUNET_CRYPTO_write_private_key_to_buffer (caller_id,
+                                                   &ccm[1], key_len);
+      ccm->key_len = htonl (key_len);
+      GNUNET_MQ_send (call->mq,
+                      e);
+      call->state = CS_RINGING;
+      call->event_handler (call->event_handler_cls,
+                           GNUNET_CONVERSATION_EC_CALL_RINGING);
+      return;
+    }
+  }
+  /* not found */
+  call->event_handler (call->event_handler_cls,
+                       GNUNET_CONVERSATION_EC_CALL_GNS_FAIL);
+  GNUNET_CONVERSATION_call_stop (call);
+}
+
+
+/**
+ * We encountered an error talking with the conversation service.
+ *
+ * @param cls the `struct GNUNET_CONVERSATION_Call`
+ * @param error details about the error
+ */
+static void
+call_error_handler (void *cls,
+                    enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_CONVERSATION_Call *call = cls;
+
+  (void) error;
+  if (CS_SHUTDOWN == call->state)
+  {
+    GNUNET_CONVERSATION_call_stop (call);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              _ (
+                "Connection to conversation service lost, trying to reconnect\n"));
+  fail_call (call);
+}
+
+
+/**
+ * The call got disconnected, destroy the handle.
+ *
+ * @param call call to reconnect
+ */
+static void
+fail_call (struct GNUNET_CONVERSATION_Call *call)
+{
+  if (CS_ACTIVE == call->state)
+  {
+    call->speaker->disable_speaker (call->speaker->cls);
+    call->mic->disable_microphone (call->mic->cls);
+  }
+  if (NULL != call->mq)
+  {
+    GNUNET_MQ_destroy (call->mq);
+    call->mq = NULL;
+  }
+  call->state = CS_SHUTDOWN;
+  call->event_handler (call->event_handler_cls,
+                       GNUNET_CONVERSATION_EC_CALL_ERROR);
+  GNUNET_CONVERSATION_call_stop (call);
+}
+
+
+/**
+ * Call the phone of another user.
+ *
+ * @param cfg configuration to use, specifies our phone service
+ * @param caller_id identity of the caller
+ * @param callee GNS name of the callee (used to locate the callee's record)
+ * @param speaker speaker to use (will be used automatically immediately once the
+ *        #GNUNET_CONVERSATION_EC_CALL_PICKED_UP event is generated); we will NOT generate
+ *        a ring tone on the speaker
+ * @param mic microphone to use (will be used automatically immediately once the
+ *        #GNUNET_CONVERSATION_EC_CALL_PICKED_UP event is generated)
+ * @param event_handler how to notify the owner of the phone about events
+ * @param event_handler_cls closure for @a event_handler
+ * @return handle for the call, NULL on hard errors
+ */
+struct GNUNET_CONVERSATION_Call *
+GNUNET_CONVERSATION_call_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                                struct GNUNET_IDENTITY_Ego *caller_id,
+                                const char *callee,
+                                struct GNUNET_SPEAKER_Handle *speaker,
+                                struct GNUNET_MICROPHONE_Handle *mic,
+                                GNUNET_CONVERSATION_CallEventHandler
+                                event_handler,
+                                void *event_handler_cls)
+{
+  struct GNUNET_CONVERSATION_Call *call
+    = GNUNET_new (struct GNUNET_CONVERSATION_Call);
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_fixed_size (call_suspend,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND,
+                             struct ClientPhoneSuspendMessage,
+                             call),
+    GNUNET_MQ_hd_fixed_size (call_resume,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME,
+                             struct ClientPhoneResumeMessage,
+                             call),
+    GNUNET_MQ_hd_fixed_size (call_picked_up,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP,
+                             struct ClientPhonePickedupMessage,
+                             call),
+    GNUNET_MQ_hd_fixed_size (call_hangup,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP,
+                             struct ClientPhoneHangupMessage,
+                             call),
+    GNUNET_MQ_hd_var_size (call_audio,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO,
+                           struct ClientAudioMessage,
+                           call),
+    GNUNET_MQ_handler_end ()
+  };
+
+  call->mq = GNUNET_CLIENT_connect (cfg,
+                                    "conversation",
+                                    handlers,
+                                    &call_error_handler,
+                                    call);
+  if (NULL == call->mq)
+  {
+    GNUNET_break (0);
+    GNUNET_free (call);
+    return NULL;
+  }
+  call->cfg = cfg;
+  call->caller_id = caller_id;
+  call->callee = GNUNET_strdup (callee);
+  call->speaker = speaker;
+  call->mic = mic;
+  call->event_handler = event_handler;
+  call->event_handler_cls = event_handler_cls;
+  call->gns = GNUNET_GNS_connect (cfg);
+  if (NULL == call->gns)
+  {
+    GNUNET_CONVERSATION_call_stop (call);
+    return NULL;
+  }
+  call->state = CS_LOOKUP;
+  call->gns_lookup = GNUNET_GNS_lookup_with_tld (call->gns,
+                                                 call->callee,
+                                                 GNUNET_GNSRECORD_TYPE_PHONE,
+                                                 GNUNET_GNS_LO_DEFAULT,
+                                                 &handle_gns_response,
+                                                 call);
+  if (NULL == call->gns_lookup)
+  {
+    GNUNET_CONVERSATION_call_stop (call);
+    return NULL;
+  }
+  return call;
+}
+
+
+/**
+ * Terminate a call.  The call may be ringing or ready at this time.
+ *
+ * @param call call to terminate
+ */
+void
+GNUNET_CONVERSATION_call_stop (struct GNUNET_CONVERSATION_Call *call)
+{
+  if ((NULL != call->speaker) &&
+      (CS_ACTIVE == call->state))
+    call->speaker->disable_speaker (call->speaker->cls);
+  if ((NULL != call->mic) &&
+      (CS_ACTIVE == call->state))
+    call->mic->disable_microphone (call->mic->cls);
+  if (CS_SHUTDOWN != call->state)
+  {
+    call->state = CS_SHUTDOWN;
+  }
+  if (NULL != call->mq)
+  {
+    GNUNET_MQ_destroy (call->mq);
+    call->mq = NULL;
+  }
+  if (NULL != call->gns_lookup)
+  {
+    GNUNET_GNS_lookup_with_tld_cancel (call->gns_lookup);
+    call->gns_lookup = NULL;
+  }
+  if (NULL != call->gns)
+  {
+    GNUNET_GNS_disconnect (call->gns);
+    call->gns = NULL;
+  }
+  GNUNET_free (call->callee);
+  GNUNET_free (call);
+}
+
+
+/**
+ * Pause a call.  Temporarily suspends the use of speaker and
+ * microphone.
+ *
+ * @param call call to pause
+ */
+void
+GNUNET_CONVERSATION_call_suspend (struct GNUNET_CONVERSATION_Call *call)
+{
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientPhoneSuspendMessage *suspend;
+
+  GNUNET_assert ((CS_SUSPENDED_CALLEE == call->state) ||
+                 (CS_ACTIVE == call->state));
+  if (CS_ACTIVE == call->state)
+  {
+    call->speaker->disable_speaker (call->speaker->cls);
+    call->mic->disable_microphone (call->mic->cls);
+  }
+  call->speaker = NULL;
+  call->mic = NULL;
+  e = GNUNET_MQ_msg (suspend,
+                     GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND);
+  GNUNET_MQ_send (call->mq,
+                  e);
+  if (CS_SUSPENDED_CALLER == call->state)
+    call->state = CS_SUSPENDED_BOTH;
+  else
+    call->state = CS_SUSPENDED_CALLER;
+}
+
+
+/**
+ * Resumes a call after #GNUNET_CONVERSATION_call_suspend.
+ *
+ * @param call call to resume
+ * @param speaker speaker to use
+ *        a ring tone on the speaker
+ * @param mic microphone to use
+ */
+void
+GNUNET_CONVERSATION_call_resume (struct GNUNET_CONVERSATION_Call *call,
+                                 struct GNUNET_SPEAKER_Handle *speaker,
+                                 struct GNUNET_MICROPHONE_Handle *mic)
+{
+  struct GNUNET_MQ_Envelope *e;
+  struct ClientPhoneResumeMessage *resume;
+
+  GNUNET_assert ((CS_SUSPENDED_CALLER == call->state) ||
+                 (CS_SUSPENDED_BOTH == call->state));
+  e = GNUNET_MQ_msg (resume, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME);
+  GNUNET_MQ_send (call->mq, e);
+  call->speaker = speaker;
+  call->mic = mic;
+  if (CS_SUSPENDED_CALLER == call->state)
+  {
+    call->state = CS_ACTIVE;
+    call->speaker->enable_speaker (call->speaker->cls);
+    call->mic->enable_microphone (call->mic->cls,
+                                  &transmit_call_audio,
+                                  call);
+  }
+  else
+  {
+    call->state = CS_SUSPENDED_CALLEE;
+  }
+}
+
+
+/* end of conversation_api_call.c */
diff --git a/src/contrib/service/conversation/displaydot.sh b/src/contrib/service/conversation/displaydot.sh
new file mode 100644
index 000000000..16ee23409
--- /dev/null
+++ b/src/contrib/service/conversation/displaydot.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+dot -Tpng `ls -tr1 /tmp/*rec*.dot | tail -1` | display /dev/stdin &
+dot -Tpng `ls -tr1 /tmp/*play*.dot | tail -1` | display /dev/stdin &
diff --git a/src/contrib/service/conversation/gnunet-conversation-test.c b/src/contrib/service/conversation/gnunet-conversation-test.c
new file mode 100644
index 000000000..5e6bc805f
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet-conversation-test.c
@@ -0,0 +1,265 @@
+/*
+     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 conversation/gnunet-conversation-test.c
+ * @brief tool to test speaker and microphone (for end users!)
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_speaker_lib.h"
+#include "gnunet_microphone_lib.h"
+
+/**
+ * How long do we record before we replay?
+ */
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
+
+
+/**
+ * A recording we made.
+ */
+struct Recording
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct Recording *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct Recording *prev;
+
+  /**
+   * Number of bytes that follow.
+   */
+  size_t size;
+};
+
+
+/**
+ * Final status code.
+ */
+static int ret;
+
+/**
+ * Handle to the microphone.
+ */
+static struct GNUNET_MICROPHONE_Handle *microphone;
+
+/**
+ * Handle to the speaker.
+ */
+static struct GNUNET_SPEAKER_Handle *speaker;
+
+/**
+ * Task scheduled to switch from recording to playback.
+ */
+static struct GNUNET_SCHEDULER_Task *switch_task;
+
+/**
+ * The shutdown task.
+ */
+static struct GNUNET_SCHEDULER_Task *st;
+
+/**
+ * Head of DLL with recorded frames.
+ */
+static struct Recording *rec_head;
+
+/**
+ * Tail of DLL with recorded frames.
+ */
+static struct Recording *rec_tail;
+
+
+/**
+ * Terminate test.
+ *
+ * @param cls NULL
+ */
+static void
+do_shutdown (void *cls)
+{
+  struct Recording *rec;
+
+  (void) cls;
+  if (NULL != switch_task)
+    GNUNET_SCHEDULER_cancel (switch_task);
+  if (NULL != microphone)
+    GNUNET_MICROPHONE_destroy (microphone);
+  if (NULL != speaker)
+    GNUNET_SPEAKER_destroy (speaker);
+  while (NULL != (rec = rec_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (rec_head,
+                                 rec_tail,
+                                 rec);
+    GNUNET_free (rec);
+  }
+  fprintf (stderr,
+           _ ("\nEnd of transmission.  Have a GNU day.\n"));
+}
+
+
+/**
+ * Terminate recording process and switch to playback.
+ *
+ * @param cls NULL
+ */
+static void
+switch_to_speaker (void *cls)
+{
+  (void) cls;
+  switch_task = NULL;
+  microphone->disable_microphone (microphone->cls);
+  if (GNUNET_OK !=
+      speaker->enable_speaker (speaker->cls))
+  {
+    fprintf (stderr,
+             "Failed to enable microphone\n");
+    ret = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  fprintf (stderr,
+           _ (
+             "\new are now playing your recording back.  If you can hear it, your audio settings are working..."));
+  for (struct Recording *rec = rec_head; NULL != rec; rec = rec->next)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Replaying %u bytes\n",
+                (unsigned int) rec->size);
+    speaker->play (speaker->cls,
+                   rec->size,
+                   &rec[1]);
+  }
+  GNUNET_SCHEDULER_cancel (st);
+  st = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+                                     &do_shutdown,
+                                     NULL);
+}
+
+
+/**
+ * Process recorded audio data.
+ *
+ * @param cls clsoure
+ * @param data_size number of bytes in @a data
+ * @param data audio data to play
+ */
+static void
+record (void *cls,
+        size_t data_size,
+        const void *data)
+{
+  struct Recording *rec;
+
+  (void) cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Recorded %u bytes\n",
+              (unsigned int) data_size);
+  rec = GNUNET_malloc (sizeof(struct Recording) + data_size);
+  rec->size = data_size;
+  GNUNET_memcpy (&rec[1], data, data_size);
+  GNUNET_CONTAINER_DLL_insert_tail (rec_head,
+                                    rec_tail,
+                                    rec);
+}
+
+
+/**
+ * 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)
+{
+  (void) cls;
+  (void) args;
+  (void) cfgfile;
+  microphone = GNUNET_MICROPHONE_create_from_hardware (cfg);
+  GNUNET_assert (NULL != microphone);
+  speaker = GNUNET_SPEAKER_create_from_hardware (cfg);
+  GNUNET_assert (NULL != speaker);
+  switch_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+                                              &switch_to_speaker,
+                                              NULL);
+  st = GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
+                                      NULL);
+  fprintf (stderr,
+           _ (
+             "We will now be recording you for %s. After that time, the recording will be played back to you..."),
+           GNUNET_STRINGS_relative_time_to_string (TIMEOUT, GNUNET_YES));
+  if (GNUNET_OK !=
+      microphone->enable_microphone (microphone->cls,
+                                     &record, NULL))
+  {
+    fprintf (stderr,
+             "Failed to enable microphone\n");
+    ret = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+}
+
+
+/**
+ * The main function of our code to test microphone and speaker.
+ *
+ * @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[] = {
+    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-conversation-test",
+                             gettext_noop ("help text"),
+                             options,
+                             &run,
+                             NULL)) ? ret : 1;
+  GNUNET_free_nz ((void *) argv);
+  return ret;
+}
+
+
+/* end of gnunet-conversation-test.c */
diff --git a/src/contrib/service/conversation/gnunet-conversation.c b/src/contrib/service/conversation/gnunet-conversation.c
new file mode 100644
index 000000000..41fc7bd0b
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet-conversation.c
@@ -0,0 +1,1232 @@
+/*
+   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 conversation/gnunet-conversation.c
+ * @brief conversation implementation
+ * @author Simon Dieterle
+ * @author Andreas Fuchs
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_constants.h"
+#include "gnunet_gnsrecord_lib.h"
+#include "gnunet_conversation_service.h"
+#include "gnunet_namestore_service.h"
+
+/**
+ * Maximum length allowed for the command line input.
+ */
+#define MAX_MESSAGE_LENGTH 1024
+
+#define XSTRINGIFY(x) STRINGIFY (x)
+
+#define STRINGIFY(x) (#x)
+
+/**
+ * Possible states of the phone.
+ */
+enum PhoneState
+{
+  /**
+   * We're waiting for our own idenitty.
+   */
+  PS_LOOKUP_EGO,
+
+  /**
+   * We're listening for calls
+   */
+  PS_LISTEN,
+
+  /**
+   * We accepted an incoming phone call.
+   */
+  PS_ACCEPTED,
+
+  /**
+   * Internal error
+   */
+  PS_ERROR
+};
+
+
+/**
+ * States for current outgoing call.
+ */
+enum CallState
+{
+  /**
+   * We are looking up some other participant.
+   */
+  CS_RESOLVING,
+
+  /**
+   * We are now ringing the other participant.
+   */
+  CS_RINGING,
+
+  /**
+   * The other party accepted our call and we are now connected.
+   */
+  CS_CONNECTED,
+
+  /**
+   * The call is currently suspended (by us).
+   */
+  CS_SUSPENDED
+};
+
+
+/**
+ * List of incoming calls
+ */
+struct CallList
+{
+  /**
+   * A DLL.
+   */
+  struct CallList *prev;
+
+  /**
+   * A DLL.
+   */
+  struct CallList *next;
+
+  /**
+   * Handle to hang up or activate.
+   */
+  struct GNUNET_CONVERSATION_Caller *caller;
+
+  /**
+   * Public key identifying the caller.
+   */
+  struct GNUNET_CRYPTO_PublicKey caller_id;
+
+  /**
+   * Unique number of the call.
+   */
+  unsigned int caller_num;
+};
+
+
+/**
+ * Phone handle
+ */
+static struct GNUNET_CONVERSATION_Phone *phone;
+
+/**
+ * Call handle (for active outgoing call).
+ */
+static struct GNUNET_CONVERSATION_Call *call;
+
+/**
+ * Caller handle (for active incoming call).
+ * This call handler is NOT in the #cl_head / #cl_tail list.
+ */
+static struct CallList *cl_active;
+
+/**
+ * Head of calls waiting to be accepted.
+ */
+static struct CallList *cl_head;
+
+/**
+ * Tail of calls waiting to be accepted.
+ */
+static struct CallList *cl_tail;
+
+/**
+ * Desired phone line (string to be converted to a hash).
+ */
+static char *line;
+
+/**
+ * Task which handles the commands
+ */
+static struct GNUNET_SCHEDULER_Task *handle_cmd_task;
+
+/**
+ * Our speaker.
+ */
+static struct GNUNET_SPEAKER_Handle *speaker;
+
+/**
+ * Our microphone.
+ */
+static struct GNUNET_MICROPHONE_Handle *mic;
+
+/**
+ * Our configuration.
+ */
+static struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Our ego.
+ */
+static struct GNUNET_IDENTITY_Ego *my_caller_id;
+
+/**
+ * Handle to identity service.
+ */
+static struct GNUNET_IDENTITY_Handle *id;
+
+/**
+ * Name of our ego.
+ */
+static char *ego_name;
+
+/**
+ * Public key of active conversation partner (if any).
+ */
+static struct GNUNET_CRYPTO_PublicKey peer_key;
+
+/**
+ * Name of active conversation partner (if any).
+ */
+static char *peer_name;
+
+/**
+ * File handle for stdin.
+ */
+static struct GNUNET_DISK_FileHandle *stdin_fh;
+
+/**
+ * Our phone's current state.
+ */
+static enum PhoneState phone_state;
+
+/**
+ * Our call's current state.
+ */
+static enum CallState call_state;
+
+/**
+ * Counts the number of incoming calls we have had so far.
+ */
+static unsigned int caller_num_gen;
+
+/**
+ * GNS address for this phone.
+ */
+static char *address;
+
+/**
+ * Be verbose.
+ */
+static int verbose;
+
+
+/**
+ * Function called with an event emitted by a phone.
+ *
+ * @param cls closure
+ * @param code type of the event
+ * @param caller handle for the caller
+ * @param caller_id public key of the caller (in GNS)
+ */
+static void
+phone_event_handler (void *cls,
+                     enum GNUNET_CONVERSATION_PhoneEventCode code,
+                     struct GNUNET_CONVERSATION_Caller *caller,
+                     const struct GNUNET_CRYPTO_PublicKey *caller_id)
+{
+  struct CallList *cl;
+
+  (void) cls;
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_PHONE_RING:
+    /*
+     * FIXME: we should be playing our ringtones from contrib/sounds now!
+     *
+       ring_my_bell();
+     *
+     * see https://gstreamer.freedesktop.org/documentation/application-development/highlevel/playback-components.html on how to play a wav using the gst framework being used here
+     */fprintf (
+      stdout,
+      _ (
+        "Incoming call from `%s'. Please /accept %u or /cancel %u the call.\n"),
+      GNUNET_GNSRECORD_pkey_to_zkey (caller_id),
+      caller_num_gen,
+      caller_num_gen);
+    cl = GNUNET_new (struct CallList);
+    cl->caller = caller;
+    cl->caller_id = *caller_id;
+    cl->caller_num = caller_num_gen++;
+    GNUNET_CONTAINER_DLL_insert (cl_head, cl_tail, cl);
+    break;
+
+  case GNUNET_CONVERSATION_EC_PHONE_HUNG_UP:
+    for (cl = cl_head; NULL != cl; cl = cl->next)
+      if (caller == cl->caller)
+        break;
+    if ((NULL == cl) && (caller == cl_active->caller))
+      cl = cl_active;
+    if (NULL == cl)
+    {
+      GNUNET_break (0);
+      return;
+    }
+    fprintf (stdout,
+             _ ("Call from `%s' terminated\n"),
+             GNUNET_GNSRECORD_pkey_to_zkey (&cl->caller_id));
+    if (cl == cl_active)
+    {
+      cl_active = NULL;
+      phone_state = PS_LISTEN;
+    }
+    else
+    {
+      GNUNET_CONTAINER_DLL_remove (cl_head, cl_tail, cl);
+    }
+    GNUNET_free (cl);
+    break;
+  }
+}
+
+
+/**
+ * Function called with an event emitted by a caller.
+ *
+ * @param cls closure with the `struct CallList` of the caller
+ * @param code type of the event issued by the caller
+ */
+static void
+caller_event_handler (void *cls, enum GNUNET_CONVERSATION_CallerEventCode code)
+{
+  struct CallList *cl = cls;
+
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_CALLER_SUSPEND:
+    fprintf (stdout,
+             _ ("Call from `%s' suspended by other user\n"),
+             GNUNET_GNSRECORD_pkey_to_zkey (&cl->caller_id));
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALLER_RESUME:
+    fprintf (stdout,
+             _ ("Call from `%s' resumed by other user\n"),
+             GNUNET_GNSRECORD_pkey_to_zkey (&cl->caller_id));
+    break;
+  }
+}
+
+
+/**
+ * Start our phone.
+ */
+static void
+start_phone ()
+{
+  struct GNUNET_GNSRECORD_Data rd;
+
+  if (NULL == my_caller_id)
+  {
+    fprintf (stderr,
+             _ ("Ego `%s' no longer available, phone is now down.\n"),
+             ego_name);
+    phone_state = PS_LOOKUP_EGO;
+    return;
+  }
+  GNUNET_assert (NULL == phone);
+  phone = GNUNET_CONVERSATION_phone_create (cfg,
+                                            my_caller_id,
+                                            &phone_event_handler,
+                                            NULL);
+  /* FIXME: get record and print full GNS record info later here... */
+  if (NULL == phone)
+  {
+    fprintf (stderr, "%s", _ ("Failed to setup phone (internal error)\n"));
+    phone_state = PS_ERROR;
+  }
+  else
+  {
+    GNUNET_CONVERSATION_phone_get_record (phone, &rd);
+    GNUNET_free (address);
+    address =
+      GNUNET_GNSRECORD_value_to_string (rd.record_type, rd.data, rd.data_size);
+    fprintf (
+      stdout,
+      _ (
+        "Phone active at `%s'.  Type `/help' for a list of available commands\n"),
+      address);
+    phone_state = PS_LISTEN;
+  }
+}
+
+
+/**
+ * Function called with an event emitted by a call.
+ *
+ * @param cls closure, NULL
+ * @param code type of the event on the call
+ */
+static void
+call_event_handler (void *cls, enum GNUNET_CONVERSATION_CallEventCode code)
+{
+  (void) cls;
+
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_CALL_RINGING:
+    GNUNET_break (CS_RESOLVING == call_state);
+    fprintf (stdout,
+             _ ("Resolved address of `%s'. Now ringing other party.\n"),
+             peer_name);
+    call_state = CS_RINGING;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_PICKED_UP:
+    GNUNET_break (CS_RINGING == call_state);
+    fprintf (stdout, _ ("Connection established to `%s'\n"), peer_name);
+    call_state = CS_CONNECTED;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL:
+    GNUNET_break (CS_RESOLVING == call_state);
+    fprintf (stdout, _ ("Failed to resolve `%s'\n"), peer_name);
+    GNUNET_free (peer_name);
+    peer_name = NULL;
+    call = NULL;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_HUNG_UP:
+    fprintf (stdout, _ ("Call to `%s' terminated\n"), peer_name);
+    GNUNET_free (peer_name);
+    peer_name = NULL;
+    call = NULL;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_SUSPENDED:
+    GNUNET_break (CS_CONNECTED == call_state);
+    fprintf (stdout,
+             _ ("Connection to `%s' suspended (by other user)\n"),
+             peer_name);
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_RESUMED:
+    GNUNET_break (CS_CONNECTED == call_state);
+    fprintf (stdout,
+             _ ("Connection to `%s' resumed (by other user)\n"),
+             peer_name);
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_ERROR:
+    fprintf (stdout, _ ("Error with the call, restarting it\n"));
+    GNUNET_free (peer_name);
+    peer_name = NULL;
+    call = NULL;
+    break;
+  }
+}
+
+
+/**
+ * Function declareation for executing a action
+ *
+ * @param arguments arguments given to the function
+ */
+typedef void (*ActionFunction) (const char *arguments);
+
+
+/**
+ * Structure which defines a command
+ */
+struct VoipCommand
+{
+  /**
+   * Command the user needs to enter.
+   */
+  const char *command;
+
+  /**
+   * Function to call on command.
+   */
+  ActionFunction Action;
+
+  /**
+   * Help text for the command.
+   */
+  const char *helptext;
+};
+
+
+/**
+ * Action function to print help for the command shell.
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_help (const char *args);
+
+
+/**
+ * Terminate the client
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_quit (const char *args)
+{
+  (void) args;
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * Handler for unknown command.
+ *
+ * @param msg arguments given to the command
+ */
+static void
+do_unknown (const char *msg)
+{
+  fprintf (stderr, _ ("Unknown command `%s'\n"), msg);
+}
+
+
+/**
+ * Initiating a new call
+ *
+ * @param arg arguments given to the command
+ */
+static void
+do_call (const char *arg)
+{
+  if (NULL == my_caller_id)
+  {
+    fprintf (stderr, _ ("Ego `%s' not available\n"), ego_name);
+    return;
+  }
+  if (NULL != call)
+  {
+    fprintf (stderr,
+             _ ("You are calling someone else already, hang up first!\n"));
+    return;
+  }
+  switch (phone_state)
+  {
+  case PS_LOOKUP_EGO:
+    fprintf (stderr, _ ("Ego `%s' not available\n"), ego_name);
+    return;
+
+  case PS_LISTEN:
+    /* ok to call! */
+    break;
+
+  case PS_ACCEPTED:
+    fprintf (
+      stderr,
+      _ (
+        "You are answering call from `%s', hang up or suspend that call first!\n"),
+      GNUNET_GNSRECORD_pkey_to_zkey (&peer_key));
+    return;
+
+  case PS_ERROR:
+    /* ok to call */
+    break;
+  }
+  if (NULL == arg)
+  {
+    fprintf (stderr, _ ("Call recipient missing.\n"));
+    do_help ("/call");
+    return;
+  }
+  peer_name = GNUNET_strdup (arg);
+  call_state = CS_RESOLVING;
+  GNUNET_assert (NULL == call);
+  call = GNUNET_CONVERSATION_call_start (cfg,
+                                         my_caller_id,
+                                         arg,
+                                         speaker,
+                                         mic,
+                                         &call_event_handler,
+                                         NULL);
+}
+
+
+/**
+ * Accepting an incoming call
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_accept (const char *args)
+{
+  struct CallList *cl;
+  char buf[32];
+
+  if ((NULL != call) && (CS_SUSPENDED != call_state))
+  {
+    fprintf (stderr,
+             _ ("You are calling someone else already, hang up first!\n"));
+    return;
+  }
+  switch (phone_state)
+  {
+  case PS_LOOKUP_EGO:
+    GNUNET_break (0);
+    break;
+
+  case PS_LISTEN:
+    /* this is the expected state */
+    break;
+
+  case PS_ACCEPTED:
+    fprintf (
+      stderr,
+      _ (
+        "You are answering call from `%s', hang up or suspend that call first!\n"),
+      GNUNET_GNSRECORD_pkey_to_zkey (&peer_key));
+    return;
+
+  case PS_ERROR:
+    GNUNET_break (0);
+    break;
+  }
+  cl = cl_head;
+  if (NULL == cl)
+  {
+    fprintf (stderr, _ ("There is no incoming call to accept here!\n"));
+    return;
+  }
+  if ((NULL != cl->next) || (NULL != args))
+  {
+    for (cl = cl_head; NULL != cl; cl = cl->next)
+    {
+      GNUNET_snprintf (buf, sizeof(buf), "%u", cl->caller_num);
+      if (0 == strcmp (buf, args))
+        break;
+    }
+  }
+  if (NULL == cl)
+  {
+    fprintf (stderr,
+             _ ("There is no incoming call `%s' to accept right now!\n"),
+             args);
+    return;
+  }
+  GNUNET_CONTAINER_DLL_remove (cl_head, cl_tail, cl);
+  cl_active = cl;
+  peer_key = cl->caller_id;
+  phone_state = PS_ACCEPTED;
+  GNUNET_CONVERSATION_caller_pick_up (cl->caller,
+                                      &caller_event_handler,
+                                      cl,
+                                      speaker,
+                                      mic);
+}
+
+
+/**
+ * Print address information for this phone.
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_address (const char *args)
+{
+  (void) args;
+  if (NULL == address)
+  {
+    fprintf (stdout, "%s", _ ("We currently do not have an address.\n"));
+    return;
+  }
+  fprintf (stdout, "%s\n", address);
+}
+
+
+/**
+ * Accepting an incoming call
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_status (const char *args)
+{
+  struct CallList *cl;
+
+  (void) args;
+  switch (phone_state)
+  {
+  case PS_LOOKUP_EGO:
+    fprintf (
+      stdout,
+      _ (
+        "We are currently trying to locate the private key for the ego `%s'.\n"),
+      ego_name);
+    break;
+
+  case PS_LISTEN:
+    fprintf (stdout,
+             _ (
+               "We are listening for incoming calls for ego `%s' on line `%s'.\n"),
+             ego_name,
+             line);
+    break;
+
+  case PS_ACCEPTED:
+    fprintf (stdout,
+             _ ("You are having a conversation with `%s'.\n"),
+             GNUNET_GNSRECORD_pkey_to_zkey (&peer_key));
+    ;
+    break;
+
+  case PS_ERROR:
+    fprintf (
+      stdout,
+      _ (
+        "We had an internal error setting up our phone line. You can still make calls.\n"));
+    break;
+  }
+  if (NULL != call)
+  {
+    switch (call_state)
+    {
+    case CS_RESOLVING:
+      fprintf (stdout,
+               _ ("We are trying to find the network address to call `%s'.\n"),
+               peer_name);
+      break;
+
+    case CS_RINGING:
+      fprintf (stdout,
+               _ ("We are calling `%s', their phone should be ringing.\n"),
+               peer_name);
+      break;
+
+    case CS_CONNECTED:
+      fprintf (stdout,
+               _ ("You are having a conversation with `%s'.\n"),
+               peer_name);
+      break;
+
+    case CS_SUSPENDED:
+      /* ok to accept incoming call right now */
+      break;
+    }
+  }
+  if ((NULL != cl_head) && ((cl_head != cl_active) || (cl_head != cl_tail)))
+  {
+    fprintf (stdout, "%s", _ ("Calls waiting:\n"));
+    for (cl = cl_head; NULL != cl; cl = cl->next)
+    {
+      if (cl == cl_active)
+        continue;
+      fprintf (stdout,
+               _ ("#%u: `%s'\n"),
+               cl->caller_num,
+               GNUNET_GNSRECORD_pkey_to_zkey (&cl->caller_id));
+    }
+    fprintf (stdout, "%s", "\n");
+  }
+}
+
+
+/**
+ * Suspending a call
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_suspend (const char *args)
+{
+  (void) args;
+  if (NULL != call)
+  {
+    switch (call_state)
+    {
+    case CS_RESOLVING:
+    case CS_RINGING:
+    case CS_SUSPENDED:
+      fprintf (stderr,
+               "%s",
+               _ ("There is no call that could be suspended right now.\n"));
+      return;
+
+    case CS_CONNECTED:
+      call_state = CS_SUSPENDED;
+      GNUNET_CONVERSATION_call_suspend (call);
+      return;
+    }
+  }
+  switch (phone_state)
+  {
+  case PS_LOOKUP_EGO:
+  case PS_LISTEN:
+  case PS_ERROR:
+    fprintf (stderr,
+             "%s",
+             _ ("There is no call that could be suspended right now.\n"));
+    return;
+
+  case PS_ACCEPTED:
+    /* expected state, do rejection logic */
+    break;
+  }
+  GNUNET_assert (NULL != cl_active);
+  GNUNET_CONVERSATION_caller_suspend (cl_active->caller);
+  cl_active = NULL;
+  phone_state = PS_LISTEN;
+}
+
+
+/**
+ * Resuming a call
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_resume (const char *args)
+{
+  struct CallList *cl;
+  char buf[32];
+
+  if (NULL != call)
+  {
+    switch (call_state)
+    {
+    case CS_RESOLVING:
+    case CS_RINGING:
+    case CS_CONNECTED:
+      fprintf (stderr,
+               "%s",
+               _ ("There is no call that could be resumed right now.\n"));
+      return;
+
+    case CS_SUSPENDED:
+      call_state = CS_CONNECTED;
+      GNUNET_CONVERSATION_call_resume (call, speaker, mic);
+      return;
+    }
+  }
+  switch (phone_state)
+  {
+  case PS_LOOKUP_EGO:
+  case PS_ERROR:
+    fprintf (stderr,
+             "%s",
+             _ ("There is no call that could be resumed right now.\n"));
+    return;
+
+  case PS_LISTEN:
+    /* expected state, do resume logic */
+    break;
+
+  case PS_ACCEPTED:
+    fprintf (stderr,
+             _ ("Already talking with `%s', cannot resume a call right now.\n"),
+             GNUNET_GNSRECORD_pkey_to_zkey (&peer_key));
+    return;
+  }
+  GNUNET_assert (NULL == cl_active);
+  cl = cl_head;
+  if (NULL == cl)
+  {
+    fprintf (stderr, _ ("There is no incoming call to resume here!\n"));
+    return;
+  }
+  if ((NULL != cl->next) || (NULL != args))
+  {
+    for (cl = cl_head; NULL != cl; cl = cl->next)
+    {
+      GNUNET_snprintf (buf, sizeof(buf), "%u", cl->caller_num);
+      if (0 == strcmp (buf, args))
+        break;
+    }
+  }
+  if (NULL == cl)
+  {
+    fprintf (stderr,
+             _ ("There is no incoming call `%s' to resume right now!\n"),
+             args);
+    return;
+  }
+  cl_active = cl;
+  GNUNET_CONVERSATION_caller_resume (cl_active->caller, speaker, mic);
+  phone_state = PS_ACCEPTED;
+}
+
+
+/**
+ * Rejecting a call
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_reject (const char *args)
+{
+  struct CallList *cl;
+  char buf[32];
+
+  if (NULL != call)
+  {
+    GNUNET_CONVERSATION_call_stop (call);
+    call = NULL;
+    return;
+  }
+  switch (phone_state)
+  {
+  case PS_LOOKUP_EGO:
+  case PS_ERROR:
+    fprintf (stderr,
+             "%s",
+             _ ("There is no call that could be cancelled right now.\n"));
+    return;
+
+  case PS_LISTEN:
+    /* look for active incoming calls to refuse */
+    cl = cl_head;
+    if (NULL == cl)
+    {
+      fprintf (stderr, _ ("There is no incoming call to refuse here!\n"));
+      return;
+    }
+    if ((NULL != cl->next) || (NULL != args))
+    {
+      for (cl = cl_head; NULL != cl; cl = cl->next)
+      {
+        GNUNET_snprintf (buf, sizeof(buf), "%u", cl->caller_num);
+        if (0 == strcmp (buf, args))
+          break;
+      }
+    }
+    if (NULL == cl)
+    {
+      fprintf (stderr,
+               _ ("There is no incoming call `%s' to refuse right now!\n"),
+               args);
+      return;
+    }
+    GNUNET_CONVERSATION_caller_hang_up (cl->caller);
+    GNUNET_CONTAINER_DLL_remove (cl_head, cl_tail, cl);
+    GNUNET_free (cl);
+    break;
+
+  case PS_ACCEPTED:
+    /* expected state, do rejection logic */
+    GNUNET_assert (NULL != cl_active);
+    GNUNET_CONVERSATION_caller_hang_up (cl_active->caller);
+    cl_active = NULL;
+    phone_state = PS_LISTEN;
+    break;
+  }
+}
+
+
+/**
+ * List of supported commands.
+ */
+static struct VoipCommand commands[] = {
+  { "/address",
+    &do_address,
+    gettext_noop (
+      "Use `/address' to find out which address this phone should have in GNS") },
+  { "/call", &do_call, gettext_noop ("Use `/call USER.gnu' to call USER") },
+  { "/accept",
+    &do_accept,
+    gettext_noop ("Use `/accept #NUM' to accept incoming call #NUM") },
+  { "/suspend",
+    &do_suspend,
+    gettext_noop ("Use `/suspend' to suspend the active call") },
+  { "/resume",
+    &do_resume,
+    gettext_noop (
+      "Use `/resume [#NUM]' to resume a call, #NUM is needed to resume incoming calls, no argument is needed to resume the current outgoing call.") },
+  { "/cancel",
+    &do_reject,
+    gettext_noop ("Use `/cancel' to reject or terminate a call") },
+  { "/status",
+    &do_status,
+    gettext_noop ("Use `/status' to print status information") },
+  { "/quit",
+    &do_quit,
+    gettext_noop ("Use `/quit' to terminate gnunet-conversation") },
+  { "/help",
+    &do_help,
+    gettext_noop ("Use `/help command' to get help for a specific command") },
+  { "", &do_unknown, NULL },
+  { NULL, NULL, NULL },
+};
+
+
+/**
+ * Action function to print help for the command shell.
+ *
+ * @param args arguments given to the command
+ */
+static void
+do_help (const char *args)
+{
+  unsigned int i;
+
+  i = 0;
+  while ((NULL != args) && (0 != strlen (args)) &&
+         (commands[i].Action != &do_help))
+  {
+    if (0 == strncasecmp (&args[1], &commands[i].command[1], strlen (args) - 1))
+    {
+      fprintf (stdout, "%s\n", gettext (commands[i].helptext));
+      return;
+    }
+    i++;
+  }
+  i = 0;
+  fprintf (stdout, "%s", "Available commands:\n");
+  while (commands[i].Action != &do_help)
+  {
+    fprintf (stdout, "%s\n", gettext (commands[i].command));
+    i++;
+  }
+  fprintf (stdout, "%s", "\n");
+  fprintf (stdout, "%s\n", gettext (commands[i].helptext));
+}
+
+
+/**
+ * Task run during shutdown.
+ *
+ * @param cls NULL
+ */
+static void
+do_stop_task (void *cls)
+{
+  (void) cls;
+  if (NULL != call)
+  {
+    GNUNET_CONVERSATION_call_stop (call);
+    call = NULL;
+  }
+  if (NULL != phone)
+  {
+    GNUNET_CONVERSATION_phone_destroy (phone);
+    phone = NULL;
+  }
+  if (NULL != handle_cmd_task)
+  {
+    GNUNET_SCHEDULER_cancel (handle_cmd_task);
+    handle_cmd_task = NULL;
+  }
+  if (NULL != id)
+  {
+    GNUNET_IDENTITY_disconnect (id);
+    id = NULL;
+  }
+  GNUNET_SPEAKER_destroy (speaker);
+  speaker = NULL;
+  GNUNET_MICROPHONE_destroy (mic);
+  mic = NULL;
+  GNUNET_free (ego_name);
+  ego_name = NULL;
+  GNUNET_free (peer_name);
+  peer_name = NULL;
+  phone_state = PS_ERROR;
+}
+
+
+/**
+ * Handle user command.
+ *
+ * @param message command the user typed in
+ * @param str_len number of bytes to process in @a message
+ */
+static void
+handle_command_string (char *message, size_t str_len)
+{
+  size_t i;
+  const char *ptr;
+
+  if (0 == str_len)
+    return;
+  if (message[str_len - 1] == '\n')
+    message[str_len - 1] = '\0';
+  if (message[str_len - 2] == '\r')
+    message[str_len - 2] = '\0';
+  if (0 == strlen (message))
+    return;
+  i = 0;
+  while (
+    (NULL != commands[i].command) &&
+    (0 !=
+     strncasecmp (commands[i].command, message, strlen (commands[i].command))))
+    i++;
+  ptr = &message[strlen (commands[i].command)];
+  while (isspace ((unsigned char) *ptr))
+    ptr++;
+  if ('\0' == *ptr)
+    ptr = NULL;
+  commands[i].Action (ptr);
+}
+
+
+/**
+ * Task to handle commands from the terminal.
+ *
+ * @param cls NULL
+ */
+static void
+handle_command (void *cls)
+{
+  char message[MAX_MESSAGE_LENGTH + 1];
+
+  (void) cls;
+  handle_cmd_task =
+    GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                    stdin_fh,
+                                    &handle_command,
+                                    NULL);
+  /* read message from command line and handle it */
+  memset (message, 0, MAX_MESSAGE_LENGTH + 1);
+  if (NULL == fgets (message, MAX_MESSAGE_LENGTH, stdin))
+    return;
+  handle_command_string (message, strlen (message));
+}
+
+
+/**
+ * Function called by identity service with information about egos.
+ *
+ * @param cls NULL
+ * @param ego ego handle
+ * @param ctx unused
+ * @param name name of the ego
+ */
+static void
+identity_cb (void *cls,
+             struct GNUNET_IDENTITY_Ego *ego,
+             void **ctx,
+             const char *name)
+{
+  (void) cls;
+  (void) ctx;
+  if (NULL == name)
+    return;
+  if (ego == my_caller_id)
+  {
+    if (verbose)
+      fprintf (stdout, _ ("Name of our ego changed to `%s'\n"), name);
+    GNUNET_free (ego_name);
+    ego_name = GNUNET_strdup (name);
+    return;
+  }
+  if (0 != strcmp (name, ego_name))
+    return;
+  if (NULL == ego)
+  {
+    if (verbose)
+      fprintf (stdout, _ ("Our ego `%s' was deleted!\n"), ego_name);
+    my_caller_id = NULL;
+    return;
+  }
+  my_caller_id = ego;
+  GNUNET_CONFIGURATION_set_value_string (cfg, "CONVERSATION", "LINE", line);
+  start_phone ();
+}
+
+
+/**
+ * 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 c configuration
+ */
+static void
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
+{
+  (void) cls;
+  (void) args;
+  (void) cfgfile;
+  cfg = GNUNET_CONFIGURATION_dup (c);
+  speaker = GNUNET_SPEAKER_create_from_hardware (cfg);
+  mic = GNUNET_MICROPHONE_create_from_hardware (cfg);
+  if (NULL == ego_name)
+  {
+    fprintf (stderr, "%s", _ ("You must specify the NAME of an ego to use\n"));
+    return;
+  }
+  id = GNUNET_IDENTITY_connect (cfg, &identity_cb, NULL);
+  handle_cmd_task =
+    GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_UI,
+                                        &handle_command,
+                                        NULL);
+  GNUNET_SCHEDULER_add_shutdown (&do_stop_task, NULL);
+}
+
+
+/**
+ * The main function to conversation.
+ *
+ * @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_string (
+      'e',
+      "ego",
+      "NAME",
+      gettext_noop ("sets the NAME of the ego to use for the caller ID"),
+      &ego_name),
+    GNUNET_GETOPT_option_string ('p',
+                                 "phone",
+                                 "LINE",
+                                 gettext_noop (
+                                   "sets the LINE to use for the phone"),
+                                 &line),
+    GNUNET_GETOPT_OPTION_END };
+  int ret;
+
+  int flags;
+  flags = fcntl (0, F_GETFL, 0);
+  flags |= O_NONBLOCK;
+  if (0 != fcntl (0, F_SETFL, flags))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");
+  stdin_fh = GNUNET_DISK_get_handle_from_int_fd (0);
+
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
+    return 2;
+  ret =
+    GNUNET_PROGRAM_run (argc,
+                        argv,
+                        "gnunet-conversation",
+                        gettext_noop (
+                          "Enables having a conversation with other GNUnet users."),
+                        options,
+                        &run,
+                        NULL);
+  GNUNET_free_nz ((void *) argv);
+  if (NULL != cfg)
+  {
+    GNUNET_CONFIGURATION_destroy (cfg);
+    cfg = NULL;
+  }
+  return (GNUNET_OK == ret) ? 0 : 1;
+}
+
+
+/* end of gnunet-conversation.c */
diff --git a/src/contrib/service/conversation/gnunet-helper-audio-playback-gst.c b/src/contrib/service/conversation/gnunet-helper-audio-playback-gst.c
new file mode 100644
index 000000000..f1e1e773d
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet-helper-audio-playback-gst.c
@@ -0,0 +1,405 @@
+/*
+     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 conversation/gnunet-helper-audio-playback-gst.c
+ * @brief program to playback audio data to the speaker (GStreamer version)
+ * @author LRN
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "conversation.h"
+#include "gnunet_constants.h"
+#include "gnunet_core_service.h"
+
+#include <gst/gst.h>
+#include <gst/audio/gstaudiobasesrc.h>
+#include <gst/app/gstappsrc.h>
+#include <glib.h>
+
+#define DEBUG_READ_PURE_OGG 1
+
+/**
+ * How much data to read in one go
+ */
+#define MAXLINE 4096
+
+/**
+ * Max number of microseconds to buffer in audiosink.
+ * Default is 1000
+ */
+#define BUFFER_TIME 1000
+
+/**
+ * Min number of microseconds to buffer in audiosink.
+ * Default is 1000
+ */
+#define LATENCY_TIME 1000
+
+/**
+ * Tokenizer for the data we get from stdin
+ */
+struct GNUNET_MessageStreamTokenizer *stdin_mst;
+
+/**
+ * Main pipeline.
+ */
+static GstElement *pipeline;
+
+/**
+ * Appsrc instance into which we write data for the pipeline.
+ */
+static GstElement *source;
+
+static GstElement *demuxer;
+static GstElement *decoder;
+static GstElement *conv;
+static GstElement *resampler;
+static GstElement *sink;
+
+/**
+ * Set to 1 to break the reading loop
+ */
+static int abort_read;
+
+
+static void
+sink_child_added (GstChildProxy *child_proxy,
+                  GObject *object,
+                  gchar *name,
+                  gpointer user_data)
+{
+  if (GST_IS_AUDIO_BASE_SRC (object))
+    g_object_set (object,
+                  "buffer-time", (gint64) BUFFER_TIME,
+                  "latency-time", (gint64) LATENCY_TIME,
+                  NULL);
+}
+
+
+static void
+ogg_pad_added (GstElement *element,
+               GstPad *pad,
+               gpointer data)
+{
+  GstPad *sinkpad;
+  GstElement *decoder = (GstElement *) data;
+
+  /* We can now link this pad with the opus-decoder sink pad */
+  sinkpad = gst_element_get_static_pad (decoder, "sink");
+
+  gst_pad_link (pad, sinkpad);
+
+  gst_element_link_many (decoder, conv, resampler, sink, NULL);
+
+  gst_object_unref (sinkpad);
+}
+
+
+static void
+quit ()
+{
+  if (NULL != source)
+    gst_app_src_end_of_stream (GST_APP_SRC (source));
+  if (NULL != pipeline)
+    gst_element_set_state (pipeline, GST_STATE_NULL);
+  abort_read = 1;
+}
+
+
+static gboolean
+bus_call (GstBus *bus, GstMessage *msg, gpointer data)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Bus message\n");
+  switch (GST_MESSAGE_TYPE (msg))
+  {
+  case GST_MESSAGE_EOS:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "End of stream\n");
+    quit ();
+    break;
+
+  case GST_MESSAGE_ERROR:
+    {
+      gchar  *debug;
+      GError *error;
+
+      gst_message_parse_error (msg, &error, &debug);
+      g_free (debug);
+
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Error: %s\n",
+                  error->message);
+      g_error_free (error);
+
+      quit ();
+      break;
+    }
+
+  default:
+    break;
+  }
+
+  return TRUE;
+}
+
+
+static void
+signalhandler (int s)
+{
+  quit ();
+}
+
+
+static int
+feed_buffer_to_gst (const char *audio, size_t b_len)
+{
+  GstBuffer *b;
+  gchar *bufspace;
+  GstFlowReturn flow;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Feeding %u bytes to GStreamer\n",
+              (unsigned int) b_len);
+
+  bufspace = g_memdup2 (audio, b_len);
+  b = gst_buffer_new_wrapped (bufspace, b_len);
+  if (NULL == b)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Failed to wrap a buffer\n");
+    g_free (bufspace);
+    return GNUNET_SYSERR;
+  }
+  flow = gst_app_src_push_buffer (GST_APP_SRC (source), b);
+  /* They all return GNUNET_OK, because currently player stops when
+   * data stops coming. This might need to be changed for the player
+   * to also stop when pipeline breaks.
+   */
+  switch (flow)
+  {
+  case GST_FLOW_OK:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Fed %u bytes to the pipeline\n",
+                (unsigned int) b_len);
+    break;
+
+  case GST_FLOW_FLUSHING:
+    /* buffer was dropped, because pipeline state is not PAUSED or PLAYING */
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Dropped a buffer\n");
+    break;
+
+  case GST_FLOW_EOS:
+    /* end of stream */
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "EOS\n");
+    break;
+
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Unexpected push result\n");
+    break;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Message callback
+ *
+ * @param msg message we received.
+ * @return #GNUNET_OK on success,
+ *     #GNUNET_NO to stop further processing due to disconnect (no error)
+ *     #GNUNET_SYSERR to stop further processing due to error
+ */
+static int
+stdin_receiver (void *cls,
+                const struct GNUNET_MessageHeader *msg)
+{
+  struct AudioMessage *audio;
+  size_t b_len;
+
+  switch (ntohs (msg->type))
+  {
+  case GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO:
+    audio = (struct AudioMessage *) msg;
+
+    b_len = ntohs (audio->header.size) - sizeof(struct AudioMessage);
+    feed_buffer_to_gst ((const char *) &audio[1], b_len);
+    break;
+
+  default:
+    break;
+  }
+  return GNUNET_OK;
+}
+
+
+int
+main (int argc, char **argv)
+{
+  GstBus *bus;
+  guint bus_watch_id;
+  uint64_t toff;
+
+  typedef void (*SignalHandlerPointer) (int);
+
+  SignalHandlerPointer inthandler, termhandler;
+#ifdef DEBUG_READ_PURE_OGG
+  int read_pure_ogg = getenv ("GNUNET_READ_PURE_OGG") ? 1 : 0;
+#endif
+
+  inthandler = signal (SIGINT,
+                       &signalhandler);
+  termhandler = signal (SIGTERM,
+                        &signalhandler);
+
+  /* Initialisation */
+  gst_init (&argc, &argv);
+
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_log_setup ("gnunet-helper-audio-playback-gst",
+                                   "WARNING",
+                                   NULL));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Audio sink starts\n");
+
+  stdin_mst = GNUNET_MST_create (&stdin_receiver,
+                                 NULL);
+
+  /* Create gstreamer elements */
+  pipeline = gst_pipeline_new ("audio-player");
+  source = gst_element_factory_make ("appsrc", "audio-input");
+  demuxer = gst_element_factory_make ("oggdemux", "ogg-demuxer");
+  decoder = gst_element_factory_make ("opusdec", "opus-decoder");
+  conv = gst_element_factory_make ("audioconvert", "converter");
+  resampler = gst_element_factory_make ("audioresample", "resampler");
+  sink = gst_element_factory_make ("autoaudiosink", "audiosink");
+
+  if (! pipeline || ! source || ! conv || ! resampler || ! decoder ||
+      ! demuxer || ! sink)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "One element could not be created. Exiting.\n");
+    return -1;
+  }
+
+  g_signal_connect (sink,
+                    "child-added",
+                    G_CALLBACK (sink_child_added),
+                    NULL);
+  g_signal_connect (demuxer,
+                    "pad-added",
+                    G_CALLBACK (ogg_pad_added),
+                    decoder);
+
+  /* Keep a reference to it, we operate on it */
+  gst_object_ref (GST_OBJECT (source));
+
+  /* Set up the pipeline */
+
+  /* we feed appsrc as fast as possible, it just blocks when it's full */
+  g_object_set (G_OBJECT (source),
+/*      "format", GST_FORMAT_TIME,*/
+                "block", TRUE,
+                "is-live", TRUE,
+                NULL);
+
+  g_object_set (G_OBJECT (decoder),
+/*      "plc", FALSE,*/
+/*      "apply-gain", TRUE,*/
+                "use-inband-fec", TRUE,
+                NULL);
+
+  /* we add a message handler */
+  bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
+  bus_watch_id = gst_bus_add_watch (bus, bus_call, pipeline);
+  gst_object_unref (bus);
+
+  /* we add all elements into the pipeline */
+  /* audio-input | ogg-demuxer | opus-decoder | converter | resampler | audiosink */
+  gst_bin_add_many (GST_BIN (pipeline), source, demuxer, decoder, conv,
+                    resampler, sink, NULL);
+
+  /* we link the elements together */
+  gst_element_link_many (source, demuxer, NULL);
+
+  /* Set the pipeline to "playing" state*/
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Now playing\n");
+  gst_element_set_state (pipeline, GST_STATE_PLAYING);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Running...\n");
+  /* Iterate */
+  toff = 0;
+  while (! abort_read)
+  {
+    char readbuf[MAXLINE];
+    int ret;
+
+    ret = read (0, readbuf, sizeof(readbuf));
+    if (0 > ret)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _ ("Read error from STDIN: %d %s\n"),
+                  ret, strerror (errno));
+      break;
+    }
+    toff += ret;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received %d bytes of audio data (total: %llu)\n",
+                (int) ret,
+                (unsigned long long) toff);
+    if (0 == ret)
+      break;
+#ifdef DEBUG_READ_PURE_OGG
+    if (read_pure_ogg)
+    {
+      feed_buffer_to_gst (readbuf, ret);
+    }
+    else
+#endif
+    GNUNET_MST_from_buffer (stdin_mst,
+                            readbuf,
+                            ret,
+                            GNUNET_NO,
+                            GNUNET_NO);
+  }
+  GNUNET_MST_destroy (stdin_mst);
+
+  signal (SIGINT, inthandler);
+  signal (SIGINT, termhandler);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Returned, stopping playback\n");
+  quit ();
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Deleting pipeline\n");
+  gst_object_unref (GST_OBJECT (source));
+  source = NULL;
+  gst_object_unref (GST_OBJECT (pipeline));
+  pipeline = NULL;
+  g_source_remove (bus_watch_id);
+
+  return 0;
+}
diff --git a/src/contrib/service/conversation/gnunet-helper-audio-playback.c b/src/contrib/service/conversation/gnunet-helper-audio-playback.c
new file mode 100644
index 000000000..dfa400d71
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet-helper-audio-playback.c
@@ -0,0 +1,888 @@
+/*
+     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 conversation/gnunet-helper-audio-playback.c
+ * @brief program to playback audio data to the speaker
+ * @author Siomon Dieterle
+ * @author Andreas Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "conversation.h"
+#include "gnunet_constants.h"
+#include "gnunet_core_service.h"
+
+#include <pulse/simple.h>
+#include <pulse/error.h>
+#include <pulse/rtclock.h>
+
+#include <pulse/pulseaudio.h>
+#include <opus/opus.h>
+#include <opus/opus_types.h>
+#include <ogg/ogg.h>
+
+#define DEBUG_READ_PURE_OGG 1
+#define DEBUG_DUMP_DECODED_OGG 1
+
+#define MAXLINE 4096
+
+#define SAMPLING_RATE 48000
+
+#define CHANNELS 1
+
+/* 120ms at 48000 */
+#define MAX_FRAME_SIZE (960 * 6)
+
+/**
+ * Pulseaudio specification. May change in the future.
+ */
+static pa_sample_spec sample_spec = {
+  .format = PA_SAMPLE_FLOAT32LE,
+  .rate = SAMPLING_RATE,
+  .channels = CHANNELS
+};
+
+#ifdef DEBUG_DUMP_DECODED_OGG
+static int dump_to_stdout;
+#endif
+
+/**
+ * Pulseaudio mainloop api
+ */
+static pa_mainloop_api *mainloop_api;
+
+/**
+ * Pulseaudio threaded mainloop
+ */
+static pa_threaded_mainloop *m;
+
+/**
+ * Pulseaudio context
+ */
+static pa_context *context;
+
+/**
+ * Pulseaudio output stream
+ */
+static pa_stream *stream_out;
+
+/**
+ * OPUS decoder
+ */
+static OpusDecoder *dec;
+
+/**
+ * PCM data buffer
+ */
+static float *pcm_buffer;
+
+/**
+ * Number of samples for one frame
+ */
+static int frame_size;
+
+/**
+ * Pipe we use to signal the main loop that we are ready to receive.
+ */
+static int ready_pipe[2];
+
+/**
+ * Ogg I/O state.
+ */
+static ogg_sync_state oy;
+
+/**
+ * Ogg stream state.
+ */
+static ogg_stream_state os;
+
+static int channels;
+
+static int preskip;
+
+static float gain;
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/* OggOpus spec says the numbers must be in little-endian order */
+struct OpusHeadPacket
+{
+  uint8_t magic[8];
+  uint8_t version;
+  uint8_t channels;
+  uint16_t preskip GNUNET_PACKED;
+  uint32_t sampling_rate GNUNET_PACKED;
+  uint16_t gain GNUNET_PACKED;
+  uint8_t channel_mapping;
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+/**
+ * Process an Opus header and setup the opus decoder based on it.
+ * It takes several pointers for header values which are needed
+ * elsewhere in the code.
+ */
+static OpusDecoder *
+process_header (ogg_packet *op)
+{
+  int err;
+  OpusDecoder *dec;
+  struct OpusHeadPacket header;
+
+  if (((unsigned int) op->bytes) < sizeof(header))
+    return NULL;
+  GNUNET_memcpy (&header,
+                 op->packet,
+                 sizeof(header));
+  header.preskip = GNUNET_le16toh (header.preskip);
+  header.sampling_rate = GNUNET_le32toh (header.sampling_rate);
+  header.gain = GNUNET_le16toh (header.gain);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Header: v%u, %u-ch, skip %u, %uHz, %u gain\n",
+              header.version,
+              header.channels,
+              header.preskip,
+              header.sampling_rate,
+              header.gain);
+  channels = header.channels;
+  preskip = header.preskip;
+
+  if (header.channel_mapping != 0)
+  {
+    fprintf (stderr,
+             "This implementation does not support non-mono streams\n");
+    return NULL;
+  }
+
+  dec = opus_decoder_create (SAMPLING_RATE, channels, &err);
+  if (OPUS_OK != err)
+  {
+    fprintf (stderr,
+             "Cannot create encoder: %s\n",
+             opus_strerror (err));
+    return NULL;
+  }
+  if (! dec)
+  {
+    fprintf (stderr,
+             "Decoder initialization failed: %s\n",
+             opus_strerror (err));
+    return NULL;
+  }
+
+  if (0 != header.gain)
+  {
+    /*Gain API added in a newer libopus version, if we don't have it
+       we apply the gain ourselves. We also add in a user provided
+       manual gain at the same time.*/
+    int gainadj = (int) header.gain;
+    err = opus_decoder_ctl (dec, OPUS_SET_GAIN (gainadj));
+    if (OPUS_UNIMPLEMENTED == err)
+    {
+      gain = pow (10.0, gainadj / 5120.0);
+    }
+    else if (OPUS_OK != err)
+    {
+      fprintf (stderr, "Error setting gain: %s\n", opus_strerror (err));
+      return NULL;
+    }
+  }
+
+  return dec;
+}
+
+
+#ifdef DEBUG_DUMP_DECODED_OGG
+static size_t
+fwrite_le32 (opus_int32 i32, FILE *file)
+{
+  unsigned char buf[4];
+
+  buf[0] = (unsigned char) (i32 & 0xFF);
+  buf[1] = (unsigned char) (i32 >> 8 & 0xFF);
+  buf[2] = (unsigned char) (i32 >> 16 & 0xFF);
+  buf[3] = (unsigned char) (i32 >> 24 & 0xFF);
+  return fwrite (buf, 4, 1, file);
+}
+
+
+static size_t
+fwrite_le16 (int i16, FILE *file)
+{
+  unsigned char buf[2];
+
+  buf[0] = (unsigned char) (i16 & 0xFF);
+  buf[1] = (unsigned char) (i16 >> 8 & 0xFF);
+  return fwrite (buf, 2, 1, file);
+}
+
+
+static int
+write_wav_header ()
+{
+  int ret;
+  FILE *file = stdout;
+
+  ret = fprintf (file, "RIFF") >= 0;
+  ret &= fwrite_le32 (0x7fffffff, file);
+
+  ret &= fprintf (file, "WAVEfmt ") >= 0;
+  ret &= fwrite_le32 (16, file);
+  ret &= fwrite_le16 (1, file);
+  ret &= fwrite_le16 (channels, file);
+  ret &= fwrite_le32 (SAMPLING_RATE, file);
+  ret &= fwrite_le32 (2 * channels * SAMPLING_RATE, file);
+  ret &= fwrite_le16 (2 * channels, file);
+  ret &= fwrite_le16 (16, file);
+
+  ret &= fprintf (file, "data") >= 0;
+  ret &= fwrite_le32 (0x7fffffff, file);
+
+  return ! ret ? -1 : 16;
+}
+
+
+#endif
+
+
+static int64_t
+audio_write (int64_t maxout)
+{
+  int64_t sampout = 0;
+  int tmp_skip;
+  unsigned out_len;
+  unsigned to_write;
+  float *output;
+
+#ifdef DEBUG_DUMP_DECODED_OGG
+  static int wrote_wav_header;
+
+  if (dump_to_stdout && ! wrote_wav_header)
+  {
+    write_wav_header ();
+    wrote_wav_header = 1;
+  }
+#endif
+  maxout = 0 > maxout ? 0 : maxout;
+  do
+  {
+    tmp_skip = (preskip > frame_size) ? (int) frame_size : preskip;
+    preskip -= tmp_skip;
+    output = pcm_buffer + channels * tmp_skip;
+    out_len = frame_size - tmp_skip;
+    if (out_len > MAX_FRAME_SIZE)
+      exit (6);
+    frame_size = 0;
+
+    to_write = out_len < maxout ? out_len : (unsigned) maxout;
+    if (0 < maxout)
+    {
+      int64_t wrote = 0;
+      wrote = to_write;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Writing %u * %u * %u = %llu bytes into PA\n",
+                  to_write,
+                  channels,
+                  (unsigned int) sizeof(float),
+                  (unsigned long long) (to_write * channels * sizeof(float)));
+#ifdef DEBUG_DUMP_DECODED_OGG
+      if (dump_to_stdout)
+      {
+# define fminf(_x, _y) ((_x) < (_y) ? (_x) : (_y))
+# define fmaxf(_x, _y) ((_x) > (_y) ? (_x) : (_y))
+# define float2int(flt) ((int) (floor (.5 + flt)))
+        int i;
+        int16_t *out = alloca (sizeof(short) * MAX_FRAME_SIZE * channels);
+        for (i = 0; i < (int) out_len * channels; i++)
+          out[i] = (short) float2int (fmaxf (-32768, fminf (output[i] * 32768.f,
+                                                            32767)));
+
+        fwrite (out, 2 * channels, out_len < maxout ? out_len : maxout, stdout);
+      }
+      else
+#endif
+      if (pa_stream_write
+            (stream_out, output, to_write * channels * sizeof(float), NULL, 0,
+            PA_SEEK_RELATIVE) < 0)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("pa_stream_write() failed: %s\n"),
+                    pa_strerror (pa_context_errno (context)));
+      }
+      sampout += wrote;
+      maxout -= wrote;
+    }
+  }
+  while (0 < frame_size && 0 < maxout);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Wrote %" PRId64 " samples\n",
+              sampout);
+  return sampout;
+}
+
+
+/**
+ * Pulseaudio shutdown task
+ */
+static void
+quit (int ret)
+{
+  mainloop_api->quit (mainloop_api,
+                      ret);
+  exit (ret);
+}
+
+
+static void
+ogg_demux_and_decode ()
+{
+  ogg_page og;
+  static int stream_init;
+  int64_t page_granule = 0;
+  ogg_packet op;
+  static int has_opus_stream;
+  static int has_tags_packet;
+  static int32_t opus_serialno;
+  static int64_t link_out;
+  static int64_t packet_count;
+  int eos = 0;
+  static int total_links;
+  static int gran_offset;
+
+  while (1 == ogg_sync_pageout (&oy, &og))
+  {
+    if (0 == stream_init)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Initialized the stream\n");
+      ogg_stream_init (&os, ogg_page_serialno (&og));
+      stream_init = 1;
+    }
+    if (ogg_page_serialno (&og) != os.serialno)
+    {
+      /* so all streams are read. */
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Re-set serial number\n");
+      ogg_stream_reset_serialno (&os, ogg_page_serialno (&og));
+    }
+    /*Add page to the bitstream*/
+    ogg_stream_pagein (&os, &og);
+    page_granule = ogg_page_granulepos (&og);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Reading page that ends at %" PRId64 "\n",
+                page_granule);
+    /*Extract all available packets*/
+    while (1 == ogg_stream_packetout (&os, &op))
+    {
+      /*OggOpus streams are identified by a magic string in the initial
+         stream header.*/
+      if (op.b_o_s && (op.bytes >= 8) && ! memcmp (op.packet, "OpusHead", 8))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Got Opus Header\n");
+        if (has_opus_stream && has_tags_packet)
+        {
+          /*If we're seeing another BOS OpusHead now it means
+             the stream is chained without an EOS.
+             This can easily happen if record helper is terminated unexpectedly.
+           */
+          has_opus_stream = 0;
+          if (dec)
+            opus_decoder_destroy (dec);
+          dec = NULL;
+          fprintf (stderr,
+                   "\nWarning: stream %" PRId64
+                   " ended without EOS and a new stream began.\n",
+                   (int64_t) os.serialno);
+        }
+        if (! has_opus_stream)
+        {
+          if ((packet_count > 0) && (opus_serialno == os.serialno) )
+          {
+            fprintf (stderr,
+                     "\nError: Apparent chaining without changing serial number (%"
+                     PRId64 "==%" PRId64 ").\n",
+                     (int64_t) opus_serialno, (int64_t) os.serialno);
+            quit (1);
+          }
+          opus_serialno = os.serialno;
+          has_opus_stream = 1;
+          has_tags_packet = 0;
+          link_out = 0;
+          packet_count = 0;
+          eos = 0;
+          total_links++;
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Got header for stream %" PRId64 ", this is %dth link\n",
+                      (int64_t) opus_serialno, total_links);
+        }
+        else
+        {
+          fprintf (stderr, "\nWarning: ignoring opus stream %" PRId64 "\n",
+                   (int64_t) os.serialno);
+        }
+      }
+      if (! has_opus_stream || (os.serialno != opus_serialno) )
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "breaking out\n");
+        break;
+      }
+      /*If first packet in a logical stream, process the Opus header*/
+      if (0 == packet_count)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Decoding header\n");
+        dec = process_header (&op);
+        if (! dec)
+          quit (1);
+
+        if ((0 != ogg_stream_packetout (&os, &op)) || (255 ==
+                                                       og.header[og.header_len
+                                                                 - 1]) )
+        {
+          /*The format specifies that the initial header and tags packets are on their
+             own pages. To aid implementors in discovering that their files are wrong
+             we reject them explicitly here. In some player designs files like this would
+             fail even without an explicit test.*/
+          fprintf (stderr,
+                   "Extra packets on initial header page. Invalid stream.\n");
+          quit (1);
+        }
+
+        /*Remember how many samples at the front we were told to skip
+           so that we can adjust the timestamp counting.*/
+        gran_offset = preskip;
+
+        if (! pcm_buffer)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Allocating %u * %u * %u = %llu bytes of buffer space\n",
+                      MAX_FRAME_SIZE,
+                      channels,
+                      (unsigned int) sizeof(float),
+                      (unsigned long long) (MAX_FRAME_SIZE * channels
+                                            * sizeof(float)));
+          pcm_buffer = pa_xmalloc (sizeof(float) * MAX_FRAME_SIZE * channels);
+        }
+      }
+      else if (1 == packet_count)
+      {
+        has_tags_packet = 1;
+        if ((0 != ogg_stream_packetout (&os, &op)) || (255 ==
+                                                       og.header[og.header_len
+                                                                 - 1]) )
+        {
+          fprintf (stderr,
+                   "Extra packets on initial tags page. Invalid stream.\n");
+          quit (1);
+        }
+      }
+      else
+      {
+        int ret;
+        int64_t maxout;
+        int64_t outsamp;
+
+        /*End of stream condition*/
+        if (op.e_o_s && (os.serialno == opus_serialno) )
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Got EOS\n");
+          eos = 1;         /* don't care for anything except opus eos */
+        }
+
+        /*Decode Opus packet*/
+        ret = opus_decode_float (dec,
+                                 (const unsigned char *) op.packet,
+                                 op.bytes,
+                                 pcm_buffer,
+                                 MAX_FRAME_SIZE, 0);
+
+        /*If the decoder returned less than zero, we have an error.*/
+        if (0 > ret)
+        {
+          fprintf (stderr, "Decoding error: %s\n", opus_strerror (ret));
+          break;
+        }
+        frame_size = ret;
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Decoded %d bytes/channel (%d bytes) from %u compressed bytes\n",
+                    ret,
+                    ret * channels,
+                    (unsigned int) op.bytes);
+
+        /*Apply header gain, if we're not using an opus library new
+           enough to do this internally.*/
+        if (0 != gain)
+        {
+          int i;
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Applying gain %f\n",
+                      gain);
+          for (i = 0; i < frame_size * channels; i++)
+            pcm_buffer[i] *= gain;
+        }
+
+        /*This handles making sure that our output duration respects
+           the final end-trim by not letting the output sample count
+           get ahead of the granpos indicated value.*/
+        maxout = ((page_granule - gran_offset) * SAMPLING_RATE / 48000)
+                 - link_out;
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Writing audio packet %" PRId64 ", at most %" PRId64
+                    " samples\n",
+                    packet_count, maxout);
+
+        outsamp = audio_write (0 > maxout ? 0 : maxout);
+        link_out += outsamp;
+      }
+      packet_count++;
+    }
+    if (eos)
+    {
+      has_opus_stream = 0;
+      if (dec)
+        opus_decoder_destroy (dec);
+      dec = NULL;
+    }
+  }
+}
+
+
+/**
+ * Message callback
+ *
+ * @param msg message we received.
+ * @return #GNUNET_OK on success,
+ *     #GNUNET_NO to stop further processing due to disconnect (no error)
+ *     #GNUNET_SYSERR to stop further processing due to error
+ */
+static int
+stdin_receiver (void *cls,
+                const struct GNUNET_MessageHeader *msg)
+{
+  struct AudioMessage *audio;
+  char *data;
+  size_t payload_len;
+
+  (void) cls;
+  switch (ntohs (msg->type))
+  {
+  case GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO:
+    audio = (struct AudioMessage *) msg;
+    payload_len = ntohs (audio->header.size) - sizeof(struct AudioMessage);
+
+    /*Get the ogg buffer for writing*/
+    data = ogg_sync_buffer (&oy, payload_len);
+    /*Read bitstream from input file*/
+    GNUNET_memcpy (data, (const unsigned char *) &audio[1], payload_len);
+    ogg_sync_wrote (&oy, payload_len);
+
+    ogg_demux_and_decode ();
+    break;
+
+  default:
+    break;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Callback when data is there for playback
+ */
+static void
+stream_write_callback (pa_stream *s,
+                       size_t length,
+                       void *userdata)
+{
+  /* unblock 'main' */
+  (void) userdata;
+  (void) length;
+  (void) s;
+  if (-1 != ready_pipe[1])
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Unblocking main loop!\n");
+    (void) write (ready_pipe[1], "r", 1);
+  }
+}
+
+
+/**
+ * Exit callback for SIGTERM and SIGINT
+ */
+static void
+exit_signal_callback (pa_mainloop_api *m,
+                      pa_signal_event *e,
+                      int sig,
+                      void *userdata)
+{
+  (void) m;
+  (void) e;
+  (void) sig;
+  (void) userdata;
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _ ("gnunet-helper-audio-playback - Got signal, exiting\n"));
+  quit (1);
+}
+
+
+/**
+ * Pulseaudio stream state callback
+ */
+static void
+context_state_callback (pa_context *c,
+                        void *userdata)
+{
+  int p;
+
+  (void) userdata;
+  GNUNET_assert (NULL != c);
+  switch (pa_context_get_state (c))
+  {
+  case PA_CONTEXT_CONNECTING:
+  case PA_CONTEXT_AUTHORIZING:
+  case PA_CONTEXT_SETTING_NAME:
+    break;
+
+  case PA_CONTEXT_READY:
+    {
+      GNUNET_assert (! stream_out);
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _ ("Connection established.\n"));
+      if (! (stream_out =
+               pa_stream_new (c, "GNUNET VoIP playback", &sample_spec, NULL)))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("pa_stream_new() failed: %s\n"),
+                    pa_strerror (pa_context_errno (c)));
+        goto fail;
+      }
+      pa_stream_set_write_callback (stream_out,
+                                    &stream_write_callback,
+                                    NULL);
+      if ((p =
+             pa_stream_connect_playback (stream_out, NULL,
+                                         NULL,
+                                         PA_STREAM_ADJUST_LATENCY
+                                         | PA_STREAM_INTERPOLATE_TIMING
+                                         | PA_STREAM_AUTO_TIMING_UPDATE,
+                                         NULL, NULL)) < 0)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("pa_stream_connect_playback() failed: %s\n"),
+                    pa_strerror (pa_context_errno (c)));
+        goto fail;
+      }
+      break;
+    }
+
+  case PA_CONTEXT_TERMINATED:
+    quit (0);
+    break;
+
+  case PA_CONTEXT_FAILED:
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Connection failure: %s\n"),
+                pa_strerror (pa_context_errno (c)));
+    goto fail;
+  }
+  return;
+fail:
+  quit (1);
+}
+
+
+/**
+ * Pulseaudio initialization
+ */
+static void
+pa_init ()
+{
+  int r;
+
+  if (! pa_sample_spec_valid (&sample_spec))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _ ("Wrong Spec\n"));
+  }
+  /* set up threaded playback mainloop */
+  if (! (m = pa_threaded_mainloop_new ()))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_mainloop_new() failed.\n"));
+  }
+  mainloop_api = pa_threaded_mainloop_get_api (m);
+  /* listen to signals */
+  r = pa_signal_init (mainloop_api);
+  GNUNET_assert (r == 0);
+  pa_signal_new (SIGINT, exit_signal_callback, NULL);
+  pa_signal_new (SIGTERM, exit_signal_callback, NULL);
+
+
+  /* connect to the main pulseaudio context */
+  if (! (context = pa_context_new (mainloop_api, "GNUnet VoIP")))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_context_new() failed.\n"));
+  }
+  pa_context_set_state_callback (context, context_state_callback, NULL);
+
+  if (pa_context_connect (context, NULL, 0, NULL) < 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_context_connect() failed: %s\n"),
+                pa_strerror (pa_context_errno (context)));
+  }
+  if (pa_threaded_mainloop_start (m) < 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_mainloop_run() failed.\n"));
+  }
+}
+
+
+static void
+ogg_init ()
+{
+  ogg_sync_init (&oy);
+}
+
+
+static void
+drain_callback (pa_stream*s, int success, void *userdata)
+{
+  (void) s;
+  (void) success;
+  (void) userdata;
+  pa_threaded_mainloop_signal (m,
+                               0);
+}
+
+
+/**
+ * The main function for the playback helper.
+ *
+ * @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 *argv[])
+{
+  static unsigned long long toff;
+  char readbuf[MAXLINE];
+  struct GNUNET_MessageStreamTokenizer *stdin_mst;
+  char c;
+  ssize_t ret;
+
+#ifdef DEBUG_READ_PURE_OGG
+  int read_pure_ogg = getenv ("GNUNET_READ_PURE_OGG") ? 1 : 0;
+#endif
+
+  (void) argc;
+  (void) argv;
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_log_setup ("gnunet-helper-audio-playback",
+                                   "WARNING",
+                                   NULL));
+  if (0 != pipe (ready_pipe))
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "pipe");
+    return 1;
+  }
+  stdin_mst = GNUNET_MST_create (&stdin_receiver, NULL);
+  ogg_init ();
+  pa_init ();
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Waiting for PulseAudio to be ready.\n");
+  GNUNET_assert (1 == read (ready_pipe[0], &c, 1));
+  close (ready_pipe[0]);
+  close (ready_pipe[1]);
+  ready_pipe[0] = -1;
+  ready_pipe[1] = -1;
+#ifdef DEBUG_DUMP_DECODED_OGG
+  dump_to_stdout = getenv ("GNUNET_DUMP_DECODED_OGG") ? 1 : 0;
+#endif
+  while (1)
+  {
+    ret = read (STDIN_FILENO,
+                readbuf,
+                sizeof(readbuf));
+    toff += ret;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received %d bytes of audio data (total: %llu)\n",
+                (int) ret,
+                toff);
+    if (0 > ret)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _ ("Read error from STDIN: %s\n"),
+                  strerror (errno));
+      break;
+    }
+    if (0 == ret)
+      break;
+#ifdef DEBUG_READ_PURE_OGG
+    if (read_pure_ogg)
+    {
+      char *data = ogg_sync_buffer (&oy, ret);
+      GNUNET_memcpy (data, readbuf, ret);
+      ogg_sync_wrote (&oy, ret);
+      ogg_demux_and_decode ();
+    }
+    else
+#endif
+    GNUNET_MST_from_buffer (stdin_mst,
+                            readbuf, ret,
+                            GNUNET_NO, GNUNET_NO);
+  }
+  GNUNET_MST_destroy (stdin_mst);
+  if (stream_out)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Locking\n");
+    pa_threaded_mainloop_lock (m);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Draining\n");
+    pa_operation *o = pa_stream_drain (stream_out, drain_callback, NULL);
+    while (pa_operation_get_state (o) == PA_OPERATION_RUNNING)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Waiting\n");
+      pa_threaded_mainloop_wait (m);
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Unreffing\n");
+    pa_operation_unref (o);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Unlocking\n");
+    pa_threaded_mainloop_unlock (m);
+  }
+  return 0;
+}
diff --git a/src/contrib/service/conversation/gnunet-helper-audio-record-gst.c b/src/contrib/service/conversation/gnunet-helper-audio-record-gst.c
new file mode 100644
index 000000000..883dd9eea
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet-helper-audio-record-gst.c
@@ -0,0 +1,393 @@
+/*
+     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 conversation/gnunet-helper-audio-record-gst.c
+ * @brief program to record audio data from the microphone (GStreamer version)
+ * @author LRN
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "conversation.h"
+#include "gnunet_constants.h"
+#include "gnunet_core_service.h"
+
+#include <gst/gst.h>
+#include <gst/app/gstappsink.h>
+#include <gst/audio/gstaudiobasesrc.h>
+#include <glib.h>
+
+#define DEBUG_RECORD_PURE_OGG 1
+
+/**
+ * Number of channels.
+ * Must be one of the following (from libopusenc documentation):
+ * 1, 2
+ */
+#define OPUS_CHANNELS 1
+
+/**
+ * Maximal size of a single opus packet.
+ */
+#define MAX_PAYLOAD_SIZE (1024 / OPUS_CHANNELS)
+
+/**
+ * Size of a single frame fed to the encoder, in ms.
+ * Must be one of the following (from libopus documentation):
+ * 2.5, 5, 10, 20, 40 or 60
+ */
+#define OPUS_FRAME_SIZE 40
+
+/**
+ * Expected packet loss to prepare for, in percents.
+ */
+#define PACKET_LOSS_PERCENTAGE 1
+
+/**
+ * Set to 1 to enable forward error correction.
+ * Set to 0 to disable.
+ */
+#define INBAND_FEC_MODE 1
+
+/**
+ * Max number of microseconds to buffer in audiosource.
+ * Default is 200000
+ */
+#define BUFFER_TIME 1000 /* 1ms */
+
+/**
+ * Min number of microseconds to buffer in audiosource.
+ * Default is 10000
+ */
+#define LATENCY_TIME 1000 /* 1ms */
+
+/**
+ * Maximum delay in multiplexing streams, in ns.
+ * Setting this to 0 forces page flushing, which
+ * decreases delay, but increases overhead.
+ */
+#define OGG_MAX_DELAY 0
+
+/**
+ * Maximum delay for sending out a page, in ns.
+ * Setting this to 0 forces page flushing, which
+ * decreases delay, but increases overhead.
+ */
+#define OGG_MAX_PAGE_DELAY 0
+
+/**
+ * Main pipeline.
+ */
+static GstElement *pipeline;
+
+#ifdef DEBUG_RECORD_PURE_OGG
+static int dump_pure_ogg;
+#endif
+
+static void
+quit ()
+{
+  if (NULL != pipeline)
+    gst_element_set_state (pipeline, GST_STATE_NULL);
+}
+
+
+static gboolean
+bus_call (GstBus *bus, GstMessage *msg, gpointer data)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Bus message\n");
+  switch (GST_MESSAGE_TYPE (msg))
+  {
+  case GST_MESSAGE_EOS:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "End of stream\n");
+    quit ();
+    break;
+
+  case GST_MESSAGE_ERROR:
+    {
+      gchar  *debug;
+      GError *error;
+
+      gst_message_parse_error (msg, &error, &debug);
+      g_free (debug);
+
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error: %s\n", error->message);
+      g_error_free (error);
+
+      quit ();
+      break;
+    }
+
+  default:
+    break;
+  }
+
+  return TRUE;
+}
+
+
+void
+source_child_added (GstChildProxy *child_proxy, GObject *object, gchar *name,
+                    gpointer user_data)
+{
+  if (GST_IS_AUDIO_BASE_SRC (object))
+    g_object_set (object, "buffer-time", (gint64) BUFFER_TIME, "latency-time",
+                  (gint64) LATENCY_TIME, NULL);
+}
+
+
+static void
+signalhandler (int s)
+{
+  quit ();
+}
+
+
+int
+main (int argc, char **argv)
+{
+  GstElement *source, *filter, *encoder, *conv, *resampler, *sink, *oggmux;
+  GstCaps *caps;
+  GstBus *bus;
+  guint bus_watch_id;
+  struct AudioMessage audio_message;
+  int abort_send = 0;
+
+  typedef void (*SignalHandlerPointer) (int);
+
+  SignalHandlerPointer inthandler, termhandler;
+  inthandler = signal (SIGINT, signalhandler);
+  termhandler = signal (SIGTERM, signalhandler);
+
+#ifdef DEBUG_RECORD_PURE_OGG
+  dump_pure_ogg = getenv ("GNUNET_RECORD_PURE_OGG") ? 1 : 0;
+#endif
+
+  /* Initialisation */
+  gst_init (&argc, &argv);
+
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_log_setup ("gnunet-helper-audio-record",
+                                   "WARNING",
+                                   NULL));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Audio source starts\n");
+
+  audio_message.header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO);
+
+  /* Create gstreamer elements */
+  pipeline = gst_pipeline_new ("audio-recorder");
+  source = gst_element_factory_make ("autoaudiosrc", "audiosource");
+  filter = gst_element_factory_make ("capsfilter", "filter");
+  conv = gst_element_factory_make ("audioconvert", "converter");
+  resampler = gst_element_factory_make ("audioresample", "resampler");
+  encoder = gst_element_factory_make ("opusenc", "opus-encoder");
+  oggmux = gst_element_factory_make ("oggmux", "ogg-muxer");
+  sink = gst_element_factory_make ("appsink", "audio-output");
+
+  if (! pipeline || ! filter || ! source || ! conv || ! resampler ||
+      ! encoder || ! oggmux || ! sink)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "One element could not be created. Exiting.\n");
+    return -1;
+  }
+
+  g_signal_connect (source, "child-added", G_CALLBACK (source_child_added),
+                    NULL);
+
+  /* Set up the pipeline */
+
+  caps = gst_caps_new_simple ("audio/x-raw",
+                              "format", G_TYPE_STRING, "S16LE",
+/*    "rate", G_TYPE_INT, SAMPLING_RATE,*/
+                              "channels", G_TYPE_INT, OPUS_CHANNELS,
+/*    "layout", G_TYPE_STRING, "interleaved",*/
+                              NULL);
+  g_object_set (G_OBJECT (filter),
+                "caps", caps,
+                NULL);
+  gst_caps_unref (caps);
+
+  g_object_set (G_OBJECT (encoder),
+/*      "bitrate", 64000, */
+/*      "bandwidth", OPUS_BANDWIDTH_FULLBAND, */
+                "inband-fec", INBAND_FEC_MODE,
+                "packet-loss-percentage", PACKET_LOSS_PERCENTAGE,
+                "max-payload-size", MAX_PAYLOAD_SIZE,
+                "audio", FALSE, /* VoIP, not audio */
+                "frame-size", OPUS_FRAME_SIZE,
+                NULL);
+
+  g_object_set (G_OBJECT (oggmux),
+                "max-delay", OGG_MAX_DELAY,
+                "max-page-delay", OGG_MAX_PAGE_DELAY,
+                NULL);
+
+  /* we add a message handler */
+  bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
+  bus_watch_id = gst_bus_add_watch (bus, bus_call, pipeline);
+  gst_object_unref (bus);
+
+  /* we add all elements into the pipeline */
+  /* audiosource | converter | resampler | opus-encoder | audio-output */
+  gst_bin_add_many (GST_BIN (pipeline), source, filter, conv, resampler,
+                    encoder,
+                    oggmux, sink, NULL);
+
+  /* we link the elements together */
+  gst_element_link_many (source, filter, conv, resampler, encoder, oggmux, sink,
+                         NULL);
+
+  /* Set the pipeline to "playing" state*/
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Now playing\n");
+  gst_element_set_state (pipeline, GST_STATE_PLAYING);
+
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Running...\n");
+  /* Iterate */
+  while (! abort_send)
+  {
+    GstSample *s;
+    GstBuffer *b;
+    GstMapInfo m;
+    size_t len, msg_size;
+    const char *ptr;
+    int phase;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "pulling...\n");
+    s = gst_app_sink_pull_sample (GST_APP_SINK (sink));
+    if (NULL == s)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "pulled NULL\n");
+      break;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "...pulled!\n");
+    {
+      const GstStructure *si;
+      char *si_str;
+      GstCaps *s_caps;
+      char *caps_str;
+      si = gst_sample_get_info (s);
+      if (si)
+      {
+        si_str = gst_structure_to_string (si);
+        if (si_str)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got sample %s\n", si_str);
+          g_free (si_str);
+        }
+      }
+      else
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got sample with no info\n");
+      s_caps = gst_sample_get_caps (s);
+      if (s_caps)
+      {
+        caps_str = gst_caps_to_string (s_caps);
+        if (caps_str)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got sample with caps %s\n",
+                      caps_str);
+          g_free (caps_str);
+        }
+      }
+      else
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got sample with no caps\n");
+    }
+    b = gst_sample_get_buffer (s);
+    if ((NULL == b) || ! gst_buffer_map (b, &m, GST_MAP_READ))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "got NULL buffer %p or failed to map the buffer\n", b);
+      gst_sample_unref (s);
+      continue;
+    }
+
+    len = m.size;
+    if (len > UINT16_MAX - sizeof(struct AudioMessage))
+    {
+      GNUNET_break (0);
+      len = UINT16_MAX - sizeof(struct AudioMessage);
+    }
+    msg_size = sizeof(struct AudioMessage) + len;
+    audio_message.header.size = htons ((uint16_t) msg_size);
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending %u bytes of audio data\n", (unsigned int) msg_size);
+    for (phase = 0; phase < 2; phase++)
+    {
+      size_t offset;
+      size_t to_send;
+      ssize_t ret;
+      if (0 == phase)
+      {
+#ifdef DEBUG_RECORD_PURE_OGG
+        if (dump_pure_ogg)
+          continue;
+#endif
+        ptr = (const char *) &audio_message;
+        to_send = sizeof(audio_message);
+      }
+      else
+      {
+        ptr = (const char *) m.data;
+        to_send = len;
+      }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Sending %u bytes on phase %d\n", (unsigned int) to_send,
+                  phase);
+      for (offset = 0; offset < to_send; offset += ret)
+      {
+        ret = write (1, &ptr[offset], to_send - offset);
+        if (0 >= ret)
+        {
+          if (-1 == ret)
+            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                        "Failed to write %u bytes at offset %u (total %u) in phase %d: %s\n",
+                        (unsigned int) (to_send - offset),
+                        (unsigned int) offset,
+                        (unsigned int) (to_send + offset),
+                        phase,
+                        strerror (errno));
+          abort_send = 1;
+          break;
+        }
+      }
+      if (abort_send)
+        break;
+    }
+    gst_buffer_unmap (b, &m);
+    gst_sample_unref (s);
+  }
+
+  signal (SIGINT, inthandler);
+  signal (SIGINT, termhandler);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Returned, stopping playback\n");
+  quit ();
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Deleting pipeline\n");
+  gst_object_unref (GST_OBJECT (pipeline));
+  pipeline = NULL;
+  g_source_remove (bus_watch_id);
+
+  return 0;
+}
diff --git a/src/contrib/service/conversation/gnunet-helper-audio-record.c b/src/contrib/service/conversation/gnunet-helper-audio-record.c
new file mode 100644
index 000000000..060a7c779
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet-helper-audio-record.c
@@ -0,0 +1,807 @@
+/*
+     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 conversation/gnunet-helper-audio-record.c
+ * @brief program to record audio data from the microphone
+ * @author Siomon Dieterle
+ * @author Andreas Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "conversation.h"
+#include "gnunet_constants.h"
+#include "gnunet_core_service.h"
+
+#include <pulse/simple.h>
+#include <pulse/error.h>
+#include <pulse/rtclock.h>
+
+#include <pulse/pulseaudio.h>
+#include <opus/opus.h>
+#include <opus/opus_types.h>
+#include <ogg/ogg.h>
+
+#define DEBUG_RECORD_PURE_OGG 1
+
+/**
+ * Sampling rate
+ */
+#define SAMPLING_RATE 48000
+
+/**
+ * How many ms of audio to buffer before encoding them.
+ * Possible values:
+ * 60, 40, 20, 10, 5, 2.5
+ */
+#define FRAME_SIZE_MS 40
+
+/**
+ * How many samples to buffer before encoding them.
+ */
+#define FRAME_SIZE (SAMPLING_RATE / 1000 * FRAME_SIZE_MS)
+
+/**
+ * Pages are committed when their size goes over this value.
+ * Note that in practice we flush pages VERY often (every frame),
+ * which means that pages NEVER really get to be this big.
+ * With one-packet-per-page, pages are roughly 100-300 bytes each.
+ *
+ * This value is chosen to make MAX_PAYLOAD_BYTES=1024 fit
+ * into a single page.
+ */
+#define PAGE_WATERLINE 800
+
+/**
+ * Maximum length of opus payload
+ */
+#define MAX_PAYLOAD_BYTES 1024
+
+/**
+ * Number of channels
+ */
+#define CHANNELS 1
+
+/**
+ * Configures the encoder's expected packet loss percentage.
+ *
+ * Higher values will trigger progressively more loss resistant behavior
+ * in the encoder at the expense of quality at a given bitrate
+ * in the lossless case, but greater quality under loss.
+ */
+#define CONV_OPUS_PACKET_LOSS_PERCENTAGE 1
+
+/**
+ * Configures the encoder's computational complexity.
+ *
+ * The supported range is 0-10 inclusive with 10 representing
+ * the highest complexity.
+ */
+#define CONV_OPUS_ENCODING_COMPLEXITY 10
+
+/**
+ * Configures the encoder's use of inband forward error correction (FEC).
+ *
+ * Note: This is only applicable to the LPC layer.
+ */
+#define CONV_OPUS_INBAND_FEC 1
+
+/**
+ * Configures the type of signal being encoded.
+ *
+ * This is a hint which helps the encoder's mode selection.
+ *
+ * Possible values:
+ * OPUS_AUTO - (default) Encoder detects the type automatically.
+ * OPUS_SIGNAL_VOICE - Bias thresholds towards choosing LPC or Hybrid modes.
+ * OPUS_SIGNAL_MUSIC - Bias thresholds towards choosing MDCT modes.
+ */
+#define CONV_OPUS_SIGNAL OPUS_SIGNAL_VOICE
+
+/**
+ * Coding mode.
+ *
+ * Possible values:
+ * OPUS_APPLICATION_VOIP - gives best quality at a given bitrate for voice
+ * signals. It enhances the input signal by high-pass filtering and
+ * emphasizing formants and harmonics. Optionally it includes in-band forward
+ * error correction to protect against packet loss. Use this mode for typical
+ * VoIP applications. Because of the enhancement, even at high bitrates
+ * the output may sound different from the input.
+ * OPUS_APPLICATION_AUDIO - gives best quality at a given bitrate for most
+ * non-voice signals like music. Use this mode for music and mixed
+ * (music/voice) content, broadcast, and applications requiring less than
+ * 15 ms of coding delay.
+ * OPUS_APPLICATION_RESTRICTED_LOWDELAY - configures low-delay mode that
+ * disables the speech-optimized mode in exchange for slightly reduced delay.
+ * This mode can only be set on an newly initialized or freshly reset encoder
+ * because it changes the codec delay.
+ */
+#define CONV_OPUS_APP_TYPE OPUS_APPLICATION_VOIP
+
+/**
+ * Specification for recording. May change in the future to spec negotiation.
+ */
+static pa_sample_spec sample_spec = {
+  .format = PA_SAMPLE_FLOAT32LE,
+  .rate = SAMPLING_RATE,
+  .channels = CHANNELS
+};
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/* OggOpus spec says the numbers must be in little-endian order */
+struct OpusHeadPacket
+{
+  uint8_t magic[8];
+  uint8_t version;
+  uint8_t channels;
+  uint16_t preskip GNUNET_PACKED;
+  uint32_t sampling_rate GNUNET_PACKED;
+  uint16_t gain GNUNET_PACKED;
+  uint8_t channel_mapping;
+};
+
+struct OpusCommentsPacket
+{
+  uint8_t magic[8];
+  uint32_t vendor_length;
+  /* followed by:
+     char vendor[vendor_length];
+     uint32_t string_count;
+     followed by @a string_count pairs of:
+       uint32_t string_length;
+       char string[string_length];
+   */
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+/**
+ * Pulseaudio mainloop api
+ */
+static pa_mainloop_api *mainloop_api;
+
+/**
+ * Pulseaudio mainloop
+ */
+static pa_mainloop *m;
+
+/**
+ * Pulseaudio context
+ */
+static pa_context *context;
+
+/**
+ * Pulseaudio recording stream
+ */
+static pa_stream *stream_in;
+
+/**
+ * Pulseaudio io events
+ */
+static pa_io_event *stdio_event;
+
+/**
+ * OPUS encoder
+ */
+static OpusEncoder *enc;
+
+/**
+ * Buffer for encoded data
+ */
+static unsigned char *opus_data;
+
+/**
+ * PCM data buffer for one OPUS frame
+ */
+static float *pcm_buffer;
+
+/**
+ * Length of the pcm data needed for one OPUS frame
+ */
+static int pcm_length;
+
+/**
+ * Audio buffer
+ */
+static char *transmit_buffer;
+
+/**
+ * Length of audio buffer
+ */
+static size_t transmit_buffer_length;
+
+/**
+ * Read index for transmit buffer
+ */
+static size_t transmit_buffer_index;
+
+/**
+ * Audio message skeleton
+ */
+static struct AudioMessage *audio_message;
+
+/**
+ * Ogg muxer state
+ */
+static ogg_stream_state os;
+
+/**
+ * Ogg packet id
+ */
+static int32_t packet_id;
+
+/**
+ * Ogg granule for current packet
+ */
+static int64_t enc_granulepos;
+
+#ifdef DEBUG_RECORD_PURE_OGG
+/**
+ * 1 to not to write GNUnet message headers,
+ * producing pure playable ogg output
+ */
+static int dump_pure_ogg;
+#endif
+
+/**
+ * Pulseaudio shutdown task
+ */
+static void
+quit (int ret)
+{
+  mainloop_api->quit (mainloop_api,
+                      ret);
+  exit (ret);
+}
+
+
+static void
+write_data (const char *ptr,
+            size_t msg_size)
+{
+  ssize_t ret;
+  size_t off;
+
+  off = 0;
+  while (off < msg_size)
+  {
+    ret = write (STDOUT_FILENO,
+                 &ptr[off],
+                 msg_size - off);
+    if (0 >= ret)
+    {
+      if (-1 == ret)
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
+                             "write");
+      quit (2);
+    }
+    off += ret;
+  }
+}
+
+
+static void
+write_page (ogg_page *og)
+{
+  static unsigned long long toff;
+  size_t msg_size;
+
+  msg_size = sizeof(struct AudioMessage) + og->header_len + og->body_len;
+  audio_message->header.size = htons ((uint16_t) msg_size);
+  GNUNET_memcpy (&audio_message[1], og->header, og->header_len);
+  GNUNET_memcpy (((char *) &audio_message[1]) + og->header_len, og->body,
+                 og->body_len);
+
+  toff += msg_size;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending %u bytes of audio data (total: %llu)\n",
+              (unsigned int) msg_size,
+              toff);
+#ifdef DEBUG_RECORD_PURE_OGG
+  if (dump_pure_ogg)
+    write_data ((const char *) &audio_message[1],
+                og->header_len + og->body_len);
+  else
+#endif
+  write_data ((const char *) audio_message,
+              msg_size);
+}
+
+
+/**
+ * Creates OPUS packets from PCM data
+ */
+static void
+packetizer ()
+{
+  char *nbuf;
+  size_t new_size;
+  int32_t len;
+  ogg_packet op;
+  ogg_page og;
+
+  while (transmit_buffer_length >= transmit_buffer_index + pcm_length)
+  {
+    GNUNET_memcpy (pcm_buffer,
+                   &transmit_buffer[transmit_buffer_index],
+                   pcm_length);
+    transmit_buffer_index += pcm_length;
+    len =
+      opus_encode_float (enc, pcm_buffer, FRAME_SIZE, opus_data,
+                         MAX_PAYLOAD_BYTES);
+
+    if (len < 0)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _ ("opus_encode_float() failed: %s. Aborting\n"),
+                  opus_strerror (len));
+      quit (5);
+    }
+    if (((uint32_t) len) > UINT16_MAX - sizeof(struct AudioMessage))
+    {
+      GNUNET_break (0);
+      continue;
+    }
+
+    /* As per OggOpus spec, granule is calculated as if the audio
+       had 48kHz sampling rate. */
+    enc_granulepos += FRAME_SIZE * 48000 / SAMPLING_RATE;
+
+    op.packet = (unsigned char *) opus_data;
+    op.bytes = len;
+    op.b_o_s = 0;
+    op.e_o_s = 0;
+    op.granulepos = enc_granulepos;
+    op.packetno = packet_id++;
+    ogg_stream_packetin (&os, &op);
+
+    while (ogg_stream_flush_fill (&os, &og, PAGE_WATERLINE))
+    {
+      if (((unsigned long long) og.header_len)
+          + ((unsigned long long) og.body_len) >
+          UINT16_MAX - sizeof(struct AudioMessage))
+      {
+        GNUNET_assert (0);
+        continue;
+      }
+      write_page (&og);
+    }
+  }
+
+  new_size = transmit_buffer_length - transmit_buffer_index;
+  if (0 != new_size)
+  {
+    nbuf = pa_xmalloc (new_size);
+    memmove (nbuf,
+             &transmit_buffer[transmit_buffer_index],
+             new_size);
+    pa_xfree (transmit_buffer);
+    transmit_buffer = nbuf;
+  }
+  else
+  {
+    pa_xfree (transmit_buffer);
+    transmit_buffer = NULL;
+  }
+  transmit_buffer_index = 0;
+  transmit_buffer_length = new_size;
+}
+
+
+/**
+ * Pulseaudio callback when new data is available.
+ */
+static void
+stream_read_callback (pa_stream *s,
+                      size_t length,
+                      void *userdata)
+{
+  const void *data;
+
+  (void) userdata;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Got %u/%d bytes of PCM data\n",
+              (unsigned int) length,
+              pcm_length);
+
+  GNUNET_assert (NULL != s);
+  GNUNET_assert (length > 0);
+  if (stdio_event)
+    mainloop_api->io_enable (stdio_event, PA_IO_EVENT_OUTPUT);
+
+  if (pa_stream_peek (s, (const void **) &data, &length) < 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_stream_peek() failed: %s\n"),
+                pa_strerror (pa_context_errno (context)));
+    quit (1);
+    return;
+  }
+  GNUNET_assert (NULL != data);
+  GNUNET_assert (length > 0);
+  if (NULL != transmit_buffer)
+  {
+    transmit_buffer = pa_xrealloc (transmit_buffer,
+                                   transmit_buffer_length + length);
+    GNUNET_memcpy (&transmit_buffer[transmit_buffer_length],
+                   data,
+                   length);
+    transmit_buffer_length += length;
+  }
+  else
+  {
+    transmit_buffer = pa_xmalloc (length);
+    GNUNET_memcpy (transmit_buffer, data, length);
+    transmit_buffer_length = length;
+    transmit_buffer_index = 0;
+  }
+  pa_stream_drop (s);
+  packetizer ();
+}
+
+
+/**
+ * Exit callback for SIGTERM and SIGINT
+ */
+static void
+exit_signal_callback (pa_mainloop_api *m,
+                      pa_signal_event *e,
+                      int sig,
+                      void *userdata)
+{
+  (void) m;
+  (void) e;
+  (void) sig;
+  (void) userdata;
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _ ("Got signal, exiting.\n"));
+  quit (1);
+}
+
+
+/**
+ * Pulseaudio stream state callback
+ */
+static void
+stream_state_callback (pa_stream *s,
+                       void *userdata)
+{
+  (void) userdata;
+  GNUNET_assert (NULL != s);
+  switch (pa_stream_get_state (s))
+  {
+  case PA_STREAM_CREATING:
+  case PA_STREAM_TERMINATED:
+    break;
+
+  case PA_STREAM_READY:
+    {
+      const pa_buffer_attr *a;
+      char cmt[PA_CHANNEL_MAP_SNPRINT_MAX];
+      char sst[PA_SAMPLE_SPEC_SNPRINT_MAX];
+
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _ ("Stream successfully created.\n"));
+
+      if (! (a = pa_stream_get_buffer_attr (s)))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("pa_stream_get_buffer_attr() failed: %s\n"),
+                    pa_strerror (pa_context_errno
+                                   (pa_stream_get_context (s))));
+      }
+      else
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                    _ ("Buffer metrics: maxlength=%u, fragsize=%u\n"),
+                    a->maxlength, a->fragsize);
+      }
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _ ("Using sample spec '%s', channel map '%s'.\n"),
+                  pa_sample_spec_snprint (sst, sizeof(sst),
+                                          pa_stream_get_sample_spec (s)),
+                  pa_channel_map_snprint (cmt, sizeof(cmt),
+                                          pa_stream_get_channel_map (s)));
+
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _ ("Connected to device %s (%u, %ssuspended).\n"),
+                  pa_stream_get_device_name (s),
+                  pa_stream_get_device_index (s),
+                  pa_stream_is_suspended (s) ? "" : "not ");
+    }
+    break;
+
+  case PA_STREAM_FAILED:
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Stream error: %s\n"),
+                pa_strerror (pa_context_errno (pa_stream_get_context (s))));
+    quit (1);
+  }
+}
+
+
+/**
+ * Pulseaudio context state callback
+ */
+static void
+context_state_callback (pa_context *c,
+                        void *userdata)
+{
+  (void) userdata;
+  GNUNET_assert (c);
+
+  switch (pa_context_get_state (c))
+  {
+  case PA_CONTEXT_CONNECTING:
+  case PA_CONTEXT_AUTHORIZING:
+  case PA_CONTEXT_SETTING_NAME:
+    break;
+
+  case PA_CONTEXT_READY:
+    {
+      int r;
+      pa_buffer_attr na;
+
+      GNUNET_assert (! stream_in);
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _ ("Connection established.\n"));
+      if (! (stream_in =
+               pa_stream_new (c, "GNUNET_VoIP recorder", &sample_spec, NULL)))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("pa_stream_new() failed: %s\n"),
+                    pa_strerror (pa_context_errno (c)));
+        goto fail;
+      }
+      pa_stream_set_state_callback (stream_in, &stream_state_callback, NULL);
+      pa_stream_set_read_callback (stream_in, &stream_read_callback, NULL);
+      memset (&na, 0, sizeof(na));
+      na.maxlength = UINT32_MAX;
+      na.fragsize = pcm_length;
+      if ((r = pa_stream_connect_record (stream_in, NULL, &na,
+                                         PA_STREAM_ADJUST_LATENCY)) < 0)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("pa_stream_connect_record() failed: %s\n"),
+                    pa_strerror (pa_context_errno (c)));
+        goto fail;
+      }
+
+      break;
+    }
+
+  case PA_CONTEXT_TERMINATED:
+    quit (0);
+    break;
+
+  case PA_CONTEXT_FAILED:
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Connection failure: %s\n"),
+                pa_strerror (pa_context_errno (c)));
+    goto fail;
+  }
+  return;
+
+fail:
+  quit (1);
+}
+
+
+/**
+ * Pulsaudio init
+ */
+static void
+pa_init ()
+{
+  int r;
+  int i;
+
+  if (! pa_sample_spec_valid (&sample_spec))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Wrong Spec\n"));
+  }
+  /* set up main record loop */
+  if (! (m = pa_mainloop_new ()))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_mainloop_new() failed.\n"));
+  }
+  mainloop_api = pa_mainloop_get_api (m);
+
+  /* listen to signals */
+  r = pa_signal_init (mainloop_api);
+  GNUNET_assert (r == 0);
+  pa_signal_new (SIGINT, &exit_signal_callback, NULL);
+  pa_signal_new (SIGTERM, &exit_signal_callback, NULL);
+
+  /* connect to the main pulseaudio context */
+
+  if (! (context = pa_context_new (mainloop_api, "GNUNET VoIP")))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_context_new() failed.\n"));
+  }
+  pa_context_set_state_callback (context, &context_state_callback, NULL);
+  if (pa_context_connect (context, NULL, 0, NULL) < 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_context_connect() failed: %s\n"),
+                pa_strerror (pa_context_errno (context)));
+  }
+  if (pa_mainloop_run (m, &i) < 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("pa_mainloop_run() failed.\n"));
+  }
+}
+
+
+/**
+ * OPUS init
+ */
+static void
+opus_init ()
+{
+  int err;
+
+  pcm_length = FRAME_SIZE * CHANNELS * sizeof(float);
+  pcm_buffer = pa_xmalloc (pcm_length);
+  opus_data = GNUNET_malloc (MAX_PAYLOAD_BYTES);
+  enc = opus_encoder_create (SAMPLING_RATE,
+                             CHANNELS,
+                             CONV_OPUS_APP_TYPE,
+                             &err);
+  opus_encoder_ctl (enc,
+                    OPUS_SET_PACKET_LOSS_PERC (
+                      CONV_OPUS_PACKET_LOSS_PERCENTAGE));
+  opus_encoder_ctl (enc,
+                    OPUS_SET_COMPLEXITY (CONV_OPUS_ENCODING_COMPLEXITY));
+  opus_encoder_ctl (enc,
+                    OPUS_SET_INBAND_FEC (CONV_OPUS_INBAND_FEC));
+  opus_encoder_ctl (enc,
+                    OPUS_SET_SIGNAL (CONV_OPUS_SIGNAL));
+}
+
+
+static void
+ogg_init ()
+{
+  int serialno;
+  struct OpusHeadPacket headpacket;
+  struct OpusCommentsPacket *commentspacket;
+  size_t commentspacket_len;
+
+  serialno = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG,
+                                       0x7FFFFFFF);
+  /*Initialize Ogg stream struct*/
+  if (-1 == ogg_stream_init (&os, serialno))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("ogg_stream_init() failed.\n"));
+    exit (3);
+  }
+
+  packet_id = 0;
+
+  /*Write header*/
+  {
+    ogg_packet op;
+    ogg_page og;
+    const char *opusver;
+    int vendor_length;
+
+    GNUNET_memcpy (headpacket.magic, "OpusHead", 8);
+    headpacket.version = 1;
+    headpacket.channels = CHANNELS;
+    headpacket.preskip = GNUNET_htole16 (0);
+    headpacket.sampling_rate = GNUNET_htole32 (SAMPLING_RATE);
+    headpacket.gain = GNUNET_htole16 (0);
+    headpacket.channel_mapping = 0; /* Mono or stereo */
+
+    op.packet = (unsigned char *) &headpacket;
+    op.bytes = sizeof(headpacket);
+    op.b_o_s = 1;
+    op.e_o_s = 0;
+    op.granulepos = 0;
+    op.packetno = packet_id++;
+    ogg_stream_packetin (&os, &op);
+
+    /* Head packet must be alone on its page */
+    while (ogg_stream_flush (&os, &og))
+    {
+      write_page (&og);
+    }
+
+    commentspacket_len = sizeof(*commentspacket);
+    opusver = opus_get_version_string ();
+    vendor_length = strlen (opusver);
+    commentspacket_len += vendor_length;
+    commentspacket_len += sizeof(uint32_t);
+
+    commentspacket = (struct OpusCommentsPacket *) malloc (commentspacket_len);
+    if (NULL == commentspacket)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _ ("Failed to allocate %u bytes for second packet\n"),
+                  (unsigned int) commentspacket_len);
+      exit (5);
+    }
+
+    GNUNET_memcpy (commentspacket->magic, "OpusTags", 8);
+    commentspacket->vendor_length = GNUNET_htole32 (vendor_length);
+    GNUNET_memcpy (&commentspacket[1], opusver, vendor_length);
+    *(uint32_t *) &((char *) &commentspacket[1])[vendor_length] = \
+      GNUNET_htole32 (0);    /* no tags */
+
+    op.packet = (unsigned char *) commentspacket;
+    op.bytes = commentspacket_len;
+    op.b_o_s = 0;
+    op.e_o_s = 0;
+    op.granulepos = 0;
+    op.packetno = packet_id++;
+    ogg_stream_packetin (&os, &op);
+
+    /* Comment packets must not be mixed with audio packets on their pages */
+    while (ogg_stream_flush (&os, &og))
+    {
+      write_page (&og);
+    }
+
+    free (commentspacket);
+  }
+}
+
+
+/**
+ * The main function for the record helper.
+ *
+ * @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 *argv[])
+{
+  (void) argc;
+  (void) argv;
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_log_setup ("gnunet-helper-audio-record",
+                                   "WARNING",
+                                   NULL));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Audio source starts\n");
+  audio_message = GNUNET_malloc (UINT16_MAX);
+  audio_message->header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO);
+
+#ifdef DEBUG_RECORD_PURE_OGG
+  dump_pure_ogg = getenv ("GNUNET_RECORD_PURE_OGG") ? 1 : 0;
+#endif
+  ogg_init ();
+  opus_init ();
+  pa_init ();
+  return 0;
+}
diff --git a/src/contrib/service/conversation/gnunet-service-conversation.c b/src/contrib/service/conversation/gnunet-service-conversation.c
new file mode 100644
index 000000000..06721e535
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet-service-conversation.c
@@ -0,0 +1,1461 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2013, 2016, 2017 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file conversation/gnunet-service-conversation.c
+ * @brief conversation service implementation
+ * @author Simon Dieterle
+ * @author Andreas Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_applications.h"
+#include "gnunet_constants.h"
+#include "gnunet_signatures.h"
+#include "gnunet_cadet_service.h"
+#include "gnunet_conversation_service.h"
+#include "conversation.h"
+
+
+/**
+ * How long is our signature on a call valid?  Needs to be long enough for time zone
+ * differences and network latency to not matter.  No strong need for it to be short,
+ * but we simply like all signatures to eventually expire.
+ */
+#define RING_TIMEOUT GNUNET_TIME_UNIT_DAYS
+
+
+/**
+ * A line connects a local client with a cadet channel (or, if it is an
+ * open line, is waiting for a cadet channel).
+ */
+struct Line;
+
+/**
+ * The possible connection status
+ */
+enum ChannelStatus
+{
+  /**
+   * We just got the connection, but no introduction yet.
+   */
+  CS_CALLEE_INIT,
+
+  /**
+   * Our phone is ringing, waiting for the client to pick up.
+   */
+  CS_CALLEE_RINGING,
+
+  /**
+   * We are talking!
+   */
+  CS_CALLEE_CONNECTED,
+
+  /**
+   * We're in shutdown, sending hangup messages before cleaning up.
+   */
+  CS_CALLEE_SHUTDOWN,
+
+  /**
+   * We are waiting for the phone to be picked up.
+   */
+  CS_CALLER_CALLING,
+
+  /**
+   * We are talking!
+   */
+  CS_CALLER_CONNECTED,
+
+  /**
+   * We're in shutdown, sending hangup messages before cleaning up.
+   */
+  CS_CALLER_SHUTDOWN
+};
+
+
+/**
+ * A `struct Channel` represents a cadet channel, which is a P2P
+ * connection to another conversation service.  Multiple channels can
+ * be attached the the same `struct Line`, which represents a local
+ * client.  We keep them in a linked list.
+ */
+struct Channel
+{
+  /**
+   * This is a DLL.
+   */
+  struct Channel *next;
+
+  /**
+   * This is a DLL.
+   */
+  struct Channel *prev;
+
+  /**
+   * Line associated with the channel.
+   */
+  struct Line *line;
+
+  /**
+   * Handle for the channel.
+   */
+  struct GNUNET_CADET_Channel *channel;
+
+  /**
+   * Message queue for control messages
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Temporary buffer for audio data in the @e mq.
+   */
+  struct GNUNET_MQ_Envelope *env;
+
+  /**
+   * Channel identifier we use for this call with the client.
+   */
+  uint32_t cid;
+
+  /**
+   * Current status of this line.
+   */
+  enum ChannelStatus status;
+
+  /**
+   * #GNUNET_YES if the channel was suspended by the other peer.
+   */
+  int8_t suspended_remote;
+
+  /**
+   * #GNUNET_YES if the channel was suspended by the local client.
+   */
+  int8_t suspended_local;
+};
+
+
+/**
+ * A `struct Line` connects a local client with cadet channels.
+ */
+struct Line
+{
+  /**
+   * This is a DLL.
+   */
+  struct Channel *channel_head;
+
+  /**
+   * This is a DLL.
+   */
+  struct Channel *channel_tail;
+
+  /**
+   * Handle to the line client.
+   */
+  struct GNUNET_SERVICE_Client *client;
+
+  /**
+   * Message queue for @e client.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Our open port.
+   */
+  struct GNUNET_CADET_Port *port;
+
+  /**
+   * Port number we are listening on (to verify signatures).
+   * Only valid if @e port is non-NULL.
+   */
+  struct GNUNET_HashCode line_port;
+
+  /**
+   * Generator for channel IDs.
+   */
+  uint32_t cid_gen;
+};
+
+
+/**
+ * Our configuration.
+ */
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Handle for cadet
+ */
+static struct GNUNET_CADET_Handle *cadet;
+
+/**
+ * Identity of this peer.
+ */
+static struct GNUNET_PeerIdentity my_identity;
+
+
+/**
+ * Given a @a cid, find the corresponding channel given
+ * a @a line.
+ *
+ * @param line a line to search
+ * @param cid what to search for
+ * @return NULL for not found
+ */
+static struct Channel *
+find_channel_by_line (struct Line *line, uint32_t cid)
+{
+  for (struct Channel *ch = line->channel_head; NULL != ch; ch = ch->next)
+    if (cid == ch->cid)
+      return ch;
+  return NULL;
+}
+
+
+/**
+ * Function to handle a pickup request message from the client
+ *
+ * @param cls the `struct Line` of the client from which the message is
+ * @param msg the message from the client
+ */
+static void
+handle_client_pickup_message (void *cls,
+                              const struct ClientPhonePickupMessage *msg)
+{
+  struct Line *line = cls;
+  struct CadetPhonePickupMessage *mppm;
+  struct GNUNET_MQ_Envelope *env;
+  struct Channel *ch;
+
+  if (NULL == line->port)
+  {
+    /* we never opened the port, bad client! */
+    GNUNET_break_op (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+  }
+  for (ch = line->channel_head; NULL != ch; ch = ch->next)
+    if (msg->cid == ch->cid)
+      break;
+  if (NULL == ch)
+  {
+    /* could have been destroyed asynchronously, ignore message */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+  }
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLEE_RINGING:
+    ch->status = CS_CALLEE_CONNECTED;
+    break;
+
+  case CS_CALLEE_CONNECTED:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLEE_SHUTDOWN:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Ignoring client's PICKUP message, line is in SHUTDOWN\n");
+    break;
+
+  case CS_CALLER_CALLING:
+  case CS_CALLER_CONNECTED:
+  case CS_CALLER_SHUTDOWN:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+  }
+  GNUNET_break (CS_CALLEE_CONNECTED == ch->status);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending PICK_UP message to cadet\n");
+  env =
+    GNUNET_MQ_msg (mppm, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP);
+  GNUNET_MQ_send (ch->mq, env);
+  GNUNET_SERVICE_client_continue (line->client);
+}
+
+
+/**
+ * Channel went down, notify client and free data
+ * structure.
+ *
+ * @param ch channel that went down
+ */
+static void
+clean_up_channel (struct Channel *ch)
+{
+  struct Line *line = ch->line;
+  struct GNUNET_MQ_Envelope *env;
+  struct ClientPhoneHangupMessage *hup;
+
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+  case CS_CALLEE_SHUTDOWN:
+  case CS_CALLER_SHUTDOWN:
+    break;
+
+  case CS_CALLEE_RINGING:
+  case CS_CALLEE_CONNECTED:
+  case CS_CALLER_CALLING:
+  case CS_CALLER_CONNECTED:
+    if (NULL != line)
+    {
+      env =
+        GNUNET_MQ_msg (hup, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP);
+      hup->cid = ch->cid;
+      GNUNET_MQ_send (line->mq, env);
+    }
+    break;
+  }
+  if (NULL != line)
+    GNUNET_CONTAINER_DLL_remove (line->channel_head, line->channel_tail, ch);
+  GNUNET_free (ch);
+}
+
+
+/**
+ * Destroy a channel.
+ *
+ * @param ch channel to destroy.
+ */
+static void
+destroy_line_cadet_channels (struct Channel *ch)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Destroying cadet channels\n");
+  if (NULL != ch->channel)
+  {
+    GNUNET_CADET_channel_destroy (ch->channel);
+    ch->channel = NULL;
+  }
+  clean_up_channel (ch);
+}
+
+
+/**
+ * We are done signalling shutdown to the other peer.  Close down
+ * the channel.
+ *
+ * @param cls the `struct Channel` to reset/terminate
+ */
+static void
+mq_done_finish_caller_shutdown (void *cls)
+{
+  struct Channel *ch = cls;
+
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+    GNUNET_break (0);
+    break;
+
+  case CS_CALLEE_RINGING:
+    GNUNET_break (0);
+    break;
+
+  case CS_CALLEE_CONNECTED:
+    GNUNET_break (0);
+    break;
+
+  case CS_CALLEE_SHUTDOWN:
+    destroy_line_cadet_channels (ch);
+    break;
+
+  case CS_CALLER_CALLING:
+    GNUNET_break (0);
+    break;
+
+  case CS_CALLER_CONNECTED:
+    GNUNET_break (0);
+    break;
+
+  case CS_CALLER_SHUTDOWN:
+    destroy_line_cadet_channels (ch);
+    break;
+  }
+}
+
+
+/**
+ * Function to handle a hangup request message from the client
+ *
+ * @param cls the `struct Line` the hangup is for
+ * @param msg the message from the client
+ */
+static void
+handle_client_hangup_message (void *cls,
+                              const struct ClientPhoneHangupMessage *msg)
+{
+  struct Line *line = cls;
+  struct GNUNET_MQ_Envelope *e;
+  struct CadetPhoneHangupMessage *mhum;
+  struct Channel *ch;
+
+  for (ch = line->channel_head; NULL != ch; ch = ch->next)
+    if (msg->cid == ch->cid)
+      break;
+  if (NULL == ch)
+  {
+    /* could have been destroyed asynchronously, ignore message */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received HANGUP for channel %u which is in state %d\n",
+              msg->cid,
+              ch->status);
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLEE_RINGING:
+    ch->status = CS_CALLEE_SHUTDOWN;
+    break;
+
+  case CS_CALLEE_CONNECTED:
+    ch->status = CS_CALLEE_SHUTDOWN;
+    break;
+
+  case CS_CALLEE_SHUTDOWN:
+    /* maybe the other peer closed asynchronously... */
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+
+  case CS_CALLER_CALLING:
+    ch->status = CS_CALLER_SHUTDOWN;
+    break;
+
+  case CS_CALLER_CONNECTED:
+    ch->status = CS_CALLER_SHUTDOWN;
+    break;
+
+  case CS_CALLER_SHUTDOWN:
+    /* maybe the other peer closed asynchronously... */
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending HANG_UP message via cadet\n");
+  e =
+    GNUNET_MQ_msg (mhum, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP);
+  GNUNET_MQ_notify_sent (e, &mq_done_finish_caller_shutdown, ch);
+  GNUNET_MQ_send (ch->mq, e);
+  GNUNET_SERVICE_client_continue (line->client);
+}
+
+
+/**
+ * Function to handle a suspend request message from the client
+ *
+ * @param cls the `struct Line` the message is about
+ * @param msg the message from the client
+ */
+static void
+handle_client_suspend_message (void *cls,
+                               const struct ClientPhoneSuspendMessage *msg)
+{
+  struct Line *line = cls;
+  struct GNUNET_MQ_Envelope *e;
+  struct CadetPhoneSuspendMessage *mhum;
+  struct Channel *ch;
+
+  for (ch = line->channel_head; NULL != ch; ch = ch->next)
+    if (msg->cid == ch->cid)
+      break;
+  if (NULL == ch)
+  {
+    /* could have been destroyed asynchronously, ignore message */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+  }
+  if (GNUNET_YES == ch->suspended_local)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received SUSPEND for channel %u which is in state %d\n",
+              msg->cid,
+              ch->status);
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLEE_RINGING:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLEE_CONNECTED:
+    ch->suspended_local = GNUNET_YES;
+    break;
+
+  case CS_CALLEE_SHUTDOWN:
+    /* maybe the other peer closed asynchronously... */
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+
+  case CS_CALLER_CALLING:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLER_CONNECTED:
+    ch->suspended_local = GNUNET_YES;
+    break;
+
+  case CS_CALLER_SHUTDOWN:
+    /* maybe the other peer closed asynchronously... */
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUSPEND message via cadet\n");
+  e =
+    GNUNET_MQ_msg (mhum, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND);
+  GNUNET_MQ_send (ch->mq, e);
+  GNUNET_SERVICE_client_continue (line->client);
+}
+
+
+/**
+ * Function to handle a resume request message from the client
+ *
+ * @param cls the `struct Line` the message is about
+ * @param msg the message from the client
+ */
+static void
+handle_client_resume_message (void *cls,
+                              const struct ClientPhoneResumeMessage *msg)
+{
+  struct Line *line = cls;
+  struct GNUNET_MQ_Envelope *e;
+  struct CadetPhoneResumeMessage *mhum;
+  struct Channel *ch;
+
+  for (ch = line->channel_head; NULL != ch; ch = ch->next)
+    if (msg->cid == ch->cid)
+      break;
+  if (NULL == ch)
+  {
+    /* could have been destroyed asynchronously, ignore message */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+  }
+  if (GNUNET_YES != ch->suspended_local)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received RESUME for channel %u which is in state %d\n",
+              msg->cid,
+              ch->status);
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLEE_RINGING:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLEE_CONNECTED:
+    ch->suspended_local = GNUNET_NO;
+    break;
+
+  case CS_CALLEE_SHUTDOWN:
+    /* maybe the other peer closed asynchronously... */
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+
+  case CS_CALLER_CALLING:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLER_CONNECTED:
+    ch->suspended_local = GNUNET_NO;
+    break;
+
+  case CS_CALLER_SHUTDOWN:
+    /* maybe the other peer closed asynchronously... */
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending RESUME message via cadet\n");
+  e = GNUNET_MQ_msg (mhum, GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME);
+  GNUNET_MQ_send (ch->mq, e);
+  GNUNET_SERVICE_client_continue (line->client);
+}
+
+
+/**
+ * Transmission of audio data via cadet channel finished.
+ *
+ * @param cls the `struct Channel` we are transmitting for
+ */
+static void
+channel_audio_sent_notify (void *cls)
+{
+  struct Channel *ch = cls;
+
+  ch->env = NULL;
+}
+
+
+/**
+ * Function to check audio data from the client
+ *
+ * @param cls the `struct Line` the message is about
+ * @param msg the message from the client
+ * @return #GNUNET_OK (any data is ok)
+ */
+static int
+check_client_audio_message (void *cls, const struct ClientAudioMessage *msg)
+{
+  (void) cls;
+  (void) msg;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function to handle audio data from the client
+ *
+ * @param cls the `struct Line` the message is about
+ * @param msg the message from the client
+ */
+static void
+handle_client_audio_message (void *cls, const struct ClientAudioMessage *msg)
+{
+  struct Line *line = cls;
+  struct CadetAudioMessage *mam;
+  struct Channel *ch;
+  size_t size;
+
+  size = ntohs (msg->header.size) - sizeof(struct ClientAudioMessage);
+  ch = find_channel_by_line (line, msg->cid);
+  if (NULL == ch)
+  {
+    /* could have been destroyed asynchronously, ignore message */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel %u not found\n", msg->cid);
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+  }
+
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+  case CS_CALLEE_RINGING:
+  case CS_CALLER_CALLING:
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+
+  case CS_CALLEE_CONNECTED:
+  case CS_CALLER_CONNECTED:
+    /* common case, handled below */
+    break;
+
+  case CS_CALLEE_SHUTDOWN:
+  case CS_CALLER_SHUTDOWN:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+                "Cadet audio channel in shutdown; audio data dropped\n");
+    GNUNET_SERVICE_client_continue (line->client);
+    return;
+  }
+  if (GNUNET_YES == ch->suspended_local)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "This channel is suspended locally\n");
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+  }
+  if (NULL != ch->env)
+  {
+    /* NOTE: we may want to not do this and instead combine the data */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Bandwidth insufficient; dropping previous audio data segment\n");
+    GNUNET_MQ_send_cancel (ch->env);
+    ch->env = NULL;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received %u bytes of AUDIO data from client CID %u\n",
+              (unsigned int) size,
+              msg->cid);
+  ch->env = GNUNET_MQ_msg_extra (mam,
+                                 size,
+                                 GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO);
+  GNUNET_memcpy (&mam[1], &msg[1], size);
+  /* FIXME: set options for unreliable transmission */
+  GNUNET_MQ_notify_sent (ch->env, &channel_audio_sent_notify, ch);
+  GNUNET_MQ_send (ch->mq, ch->env);
+  GNUNET_SERVICE_client_continue (line->client);
+}
+
+/**
+ * Function to handle a ring message incoming over cadet
+ *
+ * @param cls closure, NULL
+ * @param msg the incoming message
+ */
+static enum GNUNET_GenericReturnValue
+check_cadet_ring_message (void *cls, const struct CadetPhoneRingMessage *msg)
+{
+  // FIXME
+  return GNUNET_OK;
+}
+
+/**
+ * Function to handle a ring message incoming over cadet
+ *
+ * @param cls closure, NULL
+ * @param msg the incoming message
+ */
+static void
+handle_cadet_ring_message (void *cls, const struct CadetPhoneRingMessage *msg)
+{
+  struct Channel *ch = cls;
+  struct Line *line = ch->line;
+  struct GNUNET_MQ_Envelope *env;
+  struct ClientPhoneRingMessage *cring;
+  struct CadetPhoneRingInfoPS rs;
+  struct GNUNET_CRYPTO_PublicKey identity;
+  struct GNUNET_CRYPTO_Signature sig;
+  size_t key_len;
+  size_t sig_len;
+  size_t read;
+
+  rs.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING);
+  rs.purpose.size = htonl (sizeof(struct CadetPhoneRingInfoPS));
+  rs.line_port = line->line_port;
+  rs.target_peer = my_identity;
+  rs.expiration_time = msg->expiration_time;
+  key_len = ntohl (msg->key_len);
+  sig_len = ntohl (msg->sig_len);
+
+  if ((GNUNET_SYSERR ==
+       GNUNET_CRYPTO_read_public_key_from_buffer (&msg[1],
+                                                    key_len,
+                                                    &identity,
+                                                    &read)) ||
+      (read != key_len))
+  {
+    GNUNET_break_op (0);
+    destroy_line_cadet_channels (ch);
+    return;
+  }
+  GNUNET_CRYPTO_read_signature_from_buffer (&sig,
+                                              (char*) &msg[1] + read,
+                                              sig_len);
+  if (GNUNET_OK !=
+      GNUNET_CRYPTO_signature_verify (
+        GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING,
+        &rs,
+        &sig,
+        &identity))
+  {
+    GNUNET_break_op (0);
+    destroy_line_cadet_channels (ch);
+    return;
+  }
+  if (0 == GNUNET_TIME_absolute_get_remaining (
+        GNUNET_TIME_absolute_ntoh (msg->expiration_time))
+      .rel_value_us)
+  {
+    /* ancient call, replay? */
+    GNUNET_break_op (0);
+    /* Note that our reliance on time here is awkward; better would be
+       to use a more complex challenge-response protocol against
+       replay attacks.  Left for future work ;-). */
+    destroy_line_cadet_channels (ch);
+    return;
+  }
+  if (CS_CALLEE_INIT != ch->status)
+  {
+    GNUNET_break_op (0);
+    destroy_line_cadet_channels (ch);
+    return;
+  }
+  GNUNET_CADET_receive_done (ch->channel);
+  ch->status = CS_CALLEE_RINGING;
+  env = GNUNET_MQ_msg_extra (cring,
+                             key_len,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RING);
+  cring->cid = ch->cid;
+  memcpy (&cring[1], &msg[1], key_len);
+  cring->key_len = msg->key_len;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending RING message to client. CID is %u\n",
+              (unsigned int) ch->cid);
+  GNUNET_MQ_send (line->mq, env);
+}
+
+
+/**
+ * Function to handle a hangup message incoming over cadet
+ *
+ * @param cls closure, our `struct Channel *`
+ * @param message the incoming message
+ */
+static void
+handle_cadet_hangup_message (void *cls,
+                             const struct CadetPhoneHangupMessage *message)
+{
+  struct Channel *ch = cls;
+  struct Line *line = ch->line;
+  struct GNUNET_MQ_Envelope *env;
+  struct ClientPhoneHangupMessage *hup;
+  enum ChannelStatus status;
+  uint32_t cid;
+
+  (void) message;
+  GNUNET_CADET_receive_done (ch->channel);
+  cid = ch->cid;
+  status = ch->status;
+  destroy_line_cadet_channels (ch);
+  switch (status)
+  {
+  case CS_CALLEE_INIT:
+    GNUNET_break_op (0);
+    return;
+
+  case CS_CALLEE_RINGING:
+  case CS_CALLEE_CONNECTED:
+    break;
+
+  case CS_CALLEE_SHUTDOWN:
+    return;
+
+  case CS_CALLER_CALLING:
+  case CS_CALLER_CONNECTED:
+    break;
+
+  case CS_CALLER_SHUTDOWN:
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending HANG UP message to client\n");
+  env = GNUNET_MQ_msg (hup, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP);
+  hup->cid = cid;
+  GNUNET_MQ_send (line->mq, env);
+}
+
+
+/**
+ * Function to handle a pickup message incoming over cadet
+ *
+ * @param cls closure, our `struct Channel *`
+ * @param message the incoming message
+ */
+static void
+handle_cadet_pickup_message (void *cls,
+                             const struct CadetPhonePickupMessage *message)
+{
+  struct Channel *ch = cls;
+  struct Line *line = ch->line;
+  struct GNUNET_MQ_Envelope *env;
+  struct ClientPhonePickedupMessage *pick;
+
+  (void) message;
+  GNUNET_CADET_receive_done (ch->channel);
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+  case CS_CALLEE_RINGING:
+  case CS_CALLEE_CONNECTED:
+    GNUNET_break_op (0);
+    destroy_line_cadet_channels (ch);
+    return;
+
+  case CS_CALLEE_SHUTDOWN:
+    GNUNET_break_op (0);
+    destroy_line_cadet_channels (ch);
+    return;
+
+  case CS_CALLER_CALLING:
+    ch->status = CS_CALLER_CONNECTED;
+    break;
+
+  case CS_CALLER_CONNECTED:
+    GNUNET_break_op (0);
+    return;
+
+  case CS_CALLER_SHUTDOWN:
+    GNUNET_break_op (0);
+    mq_done_finish_caller_shutdown (ch);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending PICKED UP message to client\n");
+  env =
+    GNUNET_MQ_msg (pick, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICKED_UP);
+  pick->cid = ch->cid;
+  GNUNET_MQ_send (line->mq, env);
+}
+
+
+/**
+ * Function to handle a suspend message incoming over cadet
+ *
+ * @param cls closure, our `struct Channel *`
+ * @param message the incoming message
+ */
+static void
+handle_cadet_suspend_message (void *cls,
+                              const struct CadetPhoneSuspendMessage *message)
+{
+  struct Channel *ch = cls;
+  struct Line *line = ch->line;
+  struct GNUNET_MQ_Envelope *env;
+  struct ClientPhoneSuspendMessage *suspend;
+
+  (void) message;
+  GNUNET_CADET_receive_done (ch->channel);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Suspending channel CID: %u\n", ch->cid);
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_CALLEE_RINGING:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_CALLEE_CONNECTED:
+    ch->suspended_remote = GNUNET_YES;
+    break;
+
+  case CS_CALLEE_SHUTDOWN:
+    return;
+
+  case CS_CALLER_CALLING:
+    GNUNET_break_op (0);
+    break;
+
+  case CS_CALLER_CONNECTED:
+    ch->suspended_remote = GNUNET_YES;
+    break;
+
+  case CS_CALLER_SHUTDOWN:
+    return;
+  }
+  env =
+    GNUNET_MQ_msg (suspend, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND);
+  suspend->cid = ch->cid;
+  GNUNET_MQ_send (line->mq, env);
+}
+
+
+/**
+ * Function to handle a resume message incoming over cadet
+ *
+ * @param cls closure, our `struct Channel *`
+ * @param msg the incoming message
+ */
+static void
+handle_cadet_resume_message (void *cls,
+                             const struct CadetPhoneResumeMessage *msg)
+{
+  struct Channel *ch = cls;
+  struct Line *line;
+  struct GNUNET_MQ_Envelope *env;
+  struct ClientPhoneResumeMessage *resume;
+
+  (void) msg;
+  line = ch->line;
+  GNUNET_CADET_receive_done (ch->channel);
+  if (GNUNET_YES != ch->suspended_remote)
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_DEBUG,
+      "RESUME message received for non-suspended channel, dropping channel.\n");
+    destroy_line_cadet_channels (ch);
+    return;
+  }
+  switch (ch->status)
+  {
+  case CS_CALLEE_INIT:
+    GNUNET_break (0);
+    break;
+
+  case CS_CALLEE_RINGING:
+    GNUNET_break (0);
+    break;
+
+  case CS_CALLEE_CONNECTED:
+    ch->suspended_remote = GNUNET_NO;
+    break;
+
+  case CS_CALLEE_SHUTDOWN:
+    return;
+
+  case CS_CALLER_CALLING:
+    GNUNET_break (0);
+    break;
+
+  case CS_CALLER_CONNECTED:
+    ch->suspended_remote = GNUNET_NO;
+    break;
+
+  case CS_CALLER_SHUTDOWN:
+    return;
+  }
+  env =
+    GNUNET_MQ_msg (resume, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME);
+  resume->cid = ch->cid;
+  GNUNET_MQ_send (line->mq, env);
+}
+
+
+/**
+ * Function to check an audio message incoming over cadet
+ *
+ * @param cls closure, our `struct Channel *`
+ * @param msg the incoming message
+ * @return #GNUNET_OK (always)
+ */
+static int
+check_cadet_audio_message (void *cls, const struct CadetAudioMessage *msg)
+{
+  (void) cls;
+  (void) msg;
+  return GNUNET_OK; /* any payload is fine */
+}
+
+
+/**
+ * Function to handle an audio message incoming over cadet
+ *
+ * @param cls closure, our `struct Channel *`
+ * @param msg the incoming message
+ */
+static void
+handle_cadet_audio_message (void *cls, const struct CadetAudioMessage *msg)
+{
+  struct Channel *ch = cls;
+  size_t msize = ntohs (msg->header.size) - sizeof(struct CadetAudioMessage);
+  struct GNUNET_MQ_Envelope *env;
+  struct ClientAudioMessage *cam;
+
+  GNUNET_CADET_receive_done (ch->channel);
+  if ((GNUNET_YES == ch->suspended_local) ||
+      (GNUNET_YES == ch->suspended_remote))
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_DEBUG,
+      "Received %u bytes of AUDIO data on suspended channel CID %u; dropping\n",
+      (unsigned int) msize,
+      ch->cid);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Forwarding %u bytes of AUDIO data to client CID %u\n",
+              (unsigned int) msize,
+              ch->cid);
+  env =
+    GNUNET_MQ_msg_extra (cam, msize, GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO);
+  cam->cid = ch->cid;
+  GNUNET_memcpy (&cam[1], &msg[1], msize);
+  GNUNET_MQ_send (ch->line->mq, env);
+}
+
+
+/**
+ * Function called whenever an inbound channel is destroyed.  Should clean up
+ * any associated state.
+ *
+ * @param cls closure (set from #GNUNET_CADET_connect)
+ * @param channel connection to the other end (henceforth invalid)
+ */
+static void
+inbound_end (void *cls, const struct GNUNET_CADET_Channel *channel)
+{
+  struct Channel *ch = cls;
+
+  GNUNET_assert (channel == ch->channel);
+  ch->channel = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Channel destroyed by CADET in state %d\n",
+              ch->status);
+  clean_up_channel (ch);
+}
+
+/**
+ * Function to handle call request from the client
+ *
+ * @param cls the `struct Line` the message is about
+ * @param msg the message from the client
+ */
+static enum GNUNET_GenericReturnValue
+check_client_call_message (void *cls, const struct ClientCallMessage *msg)
+{
+  // FIXME
+  return GNUNET_OK;
+}
+
+/**
+ * Function to handle call request from the client
+ *
+ * @param cls the `struct Line` the message is about
+ * @param msg the message from the client
+ */
+static void
+handle_client_call_message (void *cls, const struct ClientCallMessage *msg)
+{
+  struct Line *line = cls;
+  struct Channel *ch = GNUNET_new (struct Channel);
+  struct GNUNET_MQ_MessageHandler cadet_handlers[] =
+  { GNUNET_MQ_hd_fixed_size (cadet_hangup_message,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP,
+                             struct CadetPhoneHangupMessage,
+                             ch),
+    GNUNET_MQ_hd_fixed_size (cadet_pickup_message,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP,
+                             struct CadetPhonePickupMessage,
+                             ch),
+    GNUNET_MQ_hd_fixed_size (cadet_suspend_message,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND,
+                             struct CadetPhoneSuspendMessage,
+                             ch),
+    GNUNET_MQ_hd_fixed_size (cadet_resume_message,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME,
+                             struct CadetPhoneResumeMessage,
+                             ch),
+    GNUNET_MQ_hd_var_size (cadet_audio_message,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO,
+                           struct CadetAudioMessage,
+                           ch),
+    GNUNET_MQ_handler_end () };
+  struct GNUNET_MQ_Envelope *e;
+  struct CadetPhoneRingMessage *ring;
+  struct CadetPhoneRingInfoPS rs;
+  struct GNUNET_CRYPTO_PrivateKey caller_id;
+  struct GNUNET_CRYPTO_PublicKey caller_id_pub;
+  struct GNUNET_CRYPTO_Signature sig;
+  ssize_t written;
+  size_t key_len;
+  size_t pkey_len;
+  size_t sig_len;
+  size_t read;
+
+  line->line_port = msg->line_port;
+  rs.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CONVERSATION_RING);
+  rs.purpose.size = htonl (sizeof(struct CadetPhoneRingInfoPS));
+  rs.line_port = line->line_port;
+  rs.target_peer = msg->target;
+  rs.expiration_time =
+    GNUNET_TIME_absolute_hton (GNUNET_TIME_relative_to_absolute (RING_TIMEOUT));
+  key_len = ntohl (msg->key_len);
+  if (GNUNET_SYSERR ==
+      GNUNET_CRYPTO_read_private_key_from_buffer (&msg[1],
+                                                    key_len,
+                                                    &caller_id,
+                                                    &read))
+  {
+    GNUNET_break_op (0);
+    GNUNET_free (ch);
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+  }
+  ch->line = line;
+  GNUNET_CONTAINER_DLL_insert (line->channel_head, line->channel_tail, ch);
+  ch->status = CS_CALLER_CALLING;
+  ch->channel = GNUNET_CADET_channel_create (cadet,
+                                             ch,
+                                             &msg->target,
+                                             &msg->line_port,
+                                             NULL,
+                                             &inbound_end,
+                                             cadet_handlers);
+  ch->mq = GNUNET_CADET_get_mq (ch->channel);
+  GNUNET_assert (read == key_len);
+  GNUNET_CRYPTO_sign (&caller_id, &rs, &sig);
+  sig_len = GNUNET_CRYPTO_signature_get_length (&sig);
+  GNUNET_CRYPTO_key_get_public (&caller_id, &caller_id_pub);
+  pkey_len = GNUNET_CRYPTO_public_key_get_length (&caller_id_pub);
+  e = GNUNET_MQ_msg_extra (ring, pkey_len + sig_len,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RING);
+  written = GNUNET_CRYPTO_write_public_key_to_buffer (&caller_id_pub,
+                                                        &ring[1],
+                                                        pkey_len);
+  ring->expiration_time = rs.expiration_time;
+  ring->key_len = htonl (pkey_len);
+  ring->sig_len = htonl (sig_len);
+  GNUNET_CRYPTO_write_signature_to_buffer (&sig,
+                                             (char *) &ring[1] + written,
+                                             sig_len);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending RING message via CADET\n");
+  GNUNET_MQ_send (ch->mq, e);
+  GNUNET_SERVICE_client_continue (line->client);
+}
+
+
+/**
+ * Method called whenever another peer has added us to a channel
+ * the other peer initiated.
+ *
+ * @param cls the `struct Line` receiving a connection
+ * @param channel new handle to the channel
+ * @param initiator peer that started the channel
+ * @return initial channel context for the channel
+ */
+static void *
+inbound_channel (void *cls,
+                 struct GNUNET_CADET_Channel *channel,
+                 const struct GNUNET_PeerIdentity *initiator)
+{
+  struct Line *line = cls;
+  struct Channel *ch;
+
+  (void) initiator;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received incoming cadet channel on line %p\n",
+              line);
+  ch = GNUNET_new (struct Channel);
+  ch->status = CS_CALLEE_INIT;
+  ch->line = line;
+  ch->channel = channel;
+  ch->mq = GNUNET_CADET_get_mq (ch->channel);
+  ch->cid = line->cid_gen++;
+  GNUNET_CONTAINER_DLL_insert (line->channel_head, line->channel_tail, ch);
+  return ch;
+}
+
+
+/**
+ * A client connected.  Initialize the `struct Line` data structure.
+ *
+ * @param cls closure, NULL
+ * @param client identification of the client
+ * @param mq message queue for @a client
+ * @return the `struct Line` for the client
+ */
+static void *
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *client,
+                   struct GNUNET_MQ_Handle *mq)
+{
+  struct Line *line;
+
+  (void) cls;
+  line = GNUNET_new (struct Line);
+  line->client = client;
+  line->mq = mq;
+  return line;
+}
+
+
+/**
+ * A client disconnected.  Remove all of its data structure entries.
+ *
+ * @param cls closure, NULL
+ * @param client identification of the client
+ * @param app_ctx our `struct Line *` for @a client
+ */
+static void
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *app_ctx)
+{
+  struct Line *line = app_ctx;
+  struct Channel *chn;
+
+  (void) cls;
+  (void) client;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client disconnected, closing line\n");
+  if (NULL != line->port)
+  {
+    GNUNET_CADET_close_port (line->port);
+    line->port = NULL;
+  }
+  for (struct Channel *ch = line->channel_head; NULL != ch; ch = chn)
+  {
+    chn = ch->next;
+    ch->line = NULL;
+    destroy_line_cadet_channels (ch);
+  }
+  GNUNET_free (line);
+}
+
+
+/**
+ * Function to register a phone.
+ *
+ * @param cls the `struct Line` of the client from which the message is
+ * @param msg the message from the client
+ */
+static void
+handle_client_register_message (void *cls,
+                                const struct ClientPhoneRegisterMessage *msg)
+{
+  struct Line *line = cls;
+  struct GNUNET_MQ_MessageHandler cadet_handlers[] =
+  { GNUNET_MQ_hd_var_size (cadet_ring_message,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RING,
+                           struct CadetPhoneRingMessage,
+                           NULL),
+    GNUNET_MQ_hd_fixed_size (cadet_hangup_message,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_HANG_UP,
+                             struct CadetPhoneHangupMessage,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (cadet_pickup_message,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_PICK_UP,
+                             struct CadetPhonePickupMessage,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (cadet_suspend_message,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_SUSPEND,
+                             struct CadetPhoneSuspendMessage,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (cadet_resume_message,
+                             GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_PHONE_RESUME,
+                             struct CadetPhoneResumeMessage,
+                             NULL),
+    GNUNET_MQ_hd_var_size (cadet_audio_message,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CADET_AUDIO,
+                           struct CadetAudioMessage,
+                           NULL),
+    GNUNET_MQ_handler_end () };
+
+  line->line_port = msg->line_port;
+  line->port = GNUNET_CADET_open_port (cadet,
+                                       &msg->line_port,
+                                       &inbound_channel,
+                                       line,
+                                       NULL,
+                                       &inbound_end,
+                                       cadet_handlers);
+  if (NULL == line->port)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Could not open line, port %s already in use!\n"),
+                GNUNET_h2s (&msg->line_port));
+    GNUNET_SERVICE_client_drop (line->client);
+    return;
+  }
+  GNUNET_SERVICE_client_continue (line->client);
+}
+
+
+/**
+ * Shutdown nicely
+ *
+ * @param cls closure, NULL
+ */
+static void
+do_shutdown (void *cls)
+{
+  (void) cls;
+  if (NULL != cadet)
+  {
+    GNUNET_CADET_disconnect (cadet);
+    cadet = NULL;
+  }
+}
+
+
+/**
+ * Main function that will be run by the scheduler.
+ *
+ * @param cls closure
+ * @param c configuration
+ * @param service service handle
+ */
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_SERVICE_Handle *service)
+{
+  (void) cls;
+  (void) service;
+  cfg = c;
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CRYPTO_get_peer_identity (cfg, &my_identity));
+  cadet = GNUNET_CADET_connect (cfg);
+  if (NULL == cadet)
+  {
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+}
+
+
+/**
+ * Define "main" method using service macro.
+ */
+GNUNET_SERVICE_MAIN (
+  "conversation",
+  GNUNET_SERVICE_OPTION_NONE,
+  &run,
+  &client_connect_cb,
+  &client_disconnect_cb,
+  NULL,
+  GNUNET_MQ_hd_fixed_size (client_register_message,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_REGISTER,
+                           struct ClientPhoneRegisterMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_pickup_message,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_PICK_UP,
+                           struct ClientPhonePickupMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_suspend_message,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_SUSPEND,
+                           struct ClientPhoneSuspendMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_resume_message,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_RESUME,
+                           struct ClientPhoneResumeMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_hangup_message,
+                           GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_HANG_UP,
+                           struct ClientPhoneHangupMessage,
+                           NULL),
+  GNUNET_MQ_hd_var_size (client_call_message,
+                         GNUNET_MESSAGE_TYPE_CONVERSATION_CS_PHONE_CALL,
+                         struct ClientCallMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (client_audio_message,
+                         GNUNET_MESSAGE_TYPE_CONVERSATION_CS_AUDIO,
+                         struct ClientAudioMessage,
+                         NULL),
+  GNUNET_MQ_handler_end ());
+
+
+/* end of gnunet-service-conversation.c */
diff --git a/src/contrib/service/conversation/gnunet_gst.c b/src/contrib/service/conversation/gnunet_gst.c
new file mode 100644
index 000000000..48d41a457
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet_gst.c
@@ -0,0 +1,1154 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 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 conversation/gnunet_gst.c
+ * @brief FIXME
+ * @author Hark
+ */
+#include "platform.h"
+#include "gnunet_gst_def.h"
+
+/**
+ * Our configuration.
+ */
+static struct GNUNET_CONFIGURATION_Handle *cfg;
+
+
+void
+dump_buffer (unsigned n, const unsigned char*buf)
+{
+  const unsigned char *p, *end;
+  unsigned i, j;
+
+  end = buf + n;
+
+  for (i = 0;; i += 16)
+  {
+    p = buf + i;
+    for (j = 0; j < 16; j++)
+    {
+      fprintf (stderr, "%02X ", p[j]);
+      if (p + j >= end)
+        goto BREAKOUT;
+    }
+    fprintf (stderr, " ");
+    p = buf + i;
+    for (j = 0; j < 16; j++)
+    {
+      fprintf (stderr, "%c", isprint (p[j]) ? p[j] :
+               '.');
+      if (p + j >= end)
+        goto BREAKOUT;
+    }
+    fprintf (stderr, "\n");
+  }
+BREAKOUT:
+  return;
+}
+
+
+/***
+ * load gnunet configuration
+ */
+void
+gg_load_configuration (GNUNET_gstData *d)
+{
+  char *audiobackend_string;
+
+  cfg = GNUNET_CONFIGURATION_create ();
+  GNUNET_CONFIGURATION_load (cfg, "mediahelper.conf");
+
+  GNUNET_CONFIGURATION_get_value_string (cfg, "MEDIAHELPER", "JACK_PP_IN",
+                                         &d->jack_pp_in);
+  GNUNET_CONFIGURATION_get_value_string (cfg, "MEDIAHELPER", "JACK_PP_OUT",
+                                         &d->jack_pp_out);
+
+  GNUNET_CONFIGURATION_get_value_string (cfg, "MEDIAHELPER", "AUDIOBACKEND",
+                                         &audiobackend_string);
+
+  // printf("abstring: %s \n", audiobackend_string);
+
+  if (0 == strcasecmp (audiobackend_string, "AUTO"))
+  {
+    d->audiobackend = AUTO;
+  }
+  else if (0 == strcasecmp (audiobackend_string, "JACK"))
+  {
+    d->audiobackend = JACK;
+  }
+  else if (0 == strcasecmp (audiobackend_string, "ALSA"))
+  {
+    d->audiobackend = ALSA;
+  }
+  else if (0 == strcasecmp (audiobackend_string, "FAKE"))
+  {
+    d->audiobackend = FAKE;
+  }
+  else if (0 == strcasecmp (audiobackend_string, "TEST"))
+  {
+    d->audiobackend = TEST;
+  }
+  else
+  {
+    d->audiobackend = AUTO;
+  }
+
+  if (GNUNET_CONFIGURATION_get_value_yesno (cfg, "MEDIAHELPER",
+                                            "REMOVESILENCE") == GNUNET_YES)
+  {
+    d->dropsilence = TRUE;
+  }
+  else
+  {
+    d->dropsilence = FALSE;
+  }
+
+  if (GNUNET_CONFIGURATION_get_value_yesno (cfg, "MEDIAHELPER",
+                                            "NO_GN_HEADERS") == GNUNET_YES)
+  {
+    d->pure_ogg = TRUE;
+  }
+  else
+  {
+    d->pure_ogg = FALSE;
+  }
+
+
+  if (GNUNET_CONFIGURATION_get_value_yesno (cfg, "MEDIAHELPER", "USERTP") ==
+      GNUNET_YES)
+  {
+    d->usertp = TRUE;
+  }
+  else
+  {
+    d->usertp = FALSE;
+  }
+
+//  GNUNET_CONFIGURATION_write(cfg, "mediahelper.conf");
+}
+
+
+static void
+write_data (const char *ptr, size_t msg_size)
+{
+  ssize_t ret;
+  size_t off;
+
+  off = 0;
+  while (off < msg_size)
+  {
+    ret = write (1, &ptr[off], msg_size - off);
+    if (0 >= ret)
+    {
+      if (-1 == ret)
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "write");
+//      quit (2);
+    }
+    off += ret;
+  }
+}
+
+
+extern GstFlowReturn
+on_appsink_new_sample (GstElement *element, GNUNET_gstData *d)
+{
+  // size of message including gnunet header
+  size_t msg_size;
+
+  GstSample *s;
+  GstBuffer *b;
+  GstMapInfo map;
+
+/*
+   const GstStructure *si;
+   char *si_str;
+   GstCaps *s_caps;
+   char *caps_str;
+ */if (gst_app_sink_is_eos (GST_APP_SINK (element)))
+    return GST_FLOW_OK;
+
+  // pull sample from appsink
+  s = gst_app_sink_pull_sample (GST_APP_SINK (element));
+
+  if (s == NULL)
+    return GST_FLOW_OK;
+
+  if (! GST_IS_SAMPLE (s))
+    return GST_FLOW_OK;
+
+  b = gst_sample_get_buffer (s);
+
+  GST_WARNING ("caps are %" GST_PTR_FORMAT, gst_sample_get_caps (s));
+
+
+  gst_buffer_map (b, &map, GST_MAP_READ);
+
+  size_t len;
+  len = map.size;
+  if (len > UINT16_MAX - sizeof(struct AudioMessage))
+  {
+    // this should never happen?
+    printf ("GSTREAMER sample too big! \n");
+    exit (20);
+    len = UINT16_MAX - sizeof(struct AudioMessage);
+  }
+
+  msg_size = sizeof(struct AudioMessage) + len;
+
+  // copy the data into audio_message
+  GNUNET_memcpy (((char *) &(d->audio_message)[1]), map.data, len);
+  (d->audio_message)->header.size = htons ((uint16_t) msg_size);
+  if (d->pure_ogg)
+    // write the audio_message without the gnunet headers
+    write_data ((const char *) &(d->audio_message)[1], len);
+  else
+    write_data ((const char *) d->audio_message, msg_size);
+
+  gst_sample_unref (s);
+  return GST_FLOW_OK;
+}
+
+
+/***
+ * Dump a pipeline graph
+ */
+extern void
+pl_graph (GstElement *pipeline)
+{
+#ifdef IS_SPEAKER
+  gst_debug_bin_to_dot_file_with_ts (GST_BIN (pipeline),
+                                     GST_DEBUG_GRAPH_SHOW_ALL,
+                                     "playback_helper.dot");
+#endif
+#ifdef IS_MIC
+  gst_debug_bin_to_dot_file_with_ts (GST_BIN (pipeline),
+                                     GST_DEBUG_GRAPH_SHOW_ALL,
+                                     "record_helper.dot");
+#endif
+
+
+  //  load_configuration();
+}
+
+
+extern gboolean
+gnunet_gst_bus_call (GstBus *bus, GstMessage *msg, gpointer data)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Bus message\n");
+  switch (GST_MESSAGE_TYPE (msg))
+  {
+  case GST_MESSAGE_EOS:
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "End of stream\n");
+    exit (10);
+    break;
+
+  case GST_MESSAGE_ERROR:
+    {
+      gchar  *debug;
+      GError *error;
+
+      gst_message_parse_error (msg, &error, &debug);
+      g_free (debug);
+
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Error: %s\n",
+                  error->message);
+      g_error_free (error);
+
+      exit (10);
+      break;
+    }
+
+  default:
+    break;
+  }
+
+  return TRUE;
+}
+
+
+/* called when pipeline changes state */
+extern void
+state_changed_cb (GstBus *bus, GstMessage *msg, GNUNET_gstData *d)
+{
+  GstState old_state, new_state, pending_state;
+
+  gst_message_parse_state_changed (msg, &old_state, &new_state,
+                                   &pending_state);
+  switch (new_state)
+  {
+  case GST_STATE_READY:
+//      printf("ready.... \n");
+    // pl_graph(GST_ELEMENT(d->pipeline));
+    break;
+
+  case GST_STATE_PLAYING:
+
+    // GST_LOG ("caps are %" GST_PTR_FORMAT, caps);
+
+    //     printf("Playing.... \n");
+    pl_graph (GST_ELEMENT (d->pipeline));
+    break;
+
+  case GST_STATE_VOID_PENDING:
+    //   printf("void_pending.... \n");
+    // pl_graph(GST_ELEMENT(d->pipeline));
+    break;
+
+  case GST_STATE_NULL:
+    //  printf("null.... \n");
+    // pl_graph(GST_ELEMENT(d->pipeline));
+    break;
+
+  case GST_STATE_PAUSED:
+    //     printf("paused.... \n");
+    // pl_graph(GST_ELEMENT(d->pipeline));
+    break;
+  }
+}
+
+
+static void
+application_cb (GstBus *bus, GstMessage *msg, GNUNET_gstData *data)
+{
+  // printf("application cb");
+  return;
+}
+
+
+static void
+error_cb (GstBus *bus, GstMessage *msg, GNUNET_gstData *data)
+{
+  // printf("error cb");
+  return;
+}
+
+
+static void
+eos_cb (GstBus *bus, GstMessage *msg, GNUNET_gstData *data)
+{
+  // printf("eos cb");
+  return;
+}
+
+
+extern void
+gg_setup_gst_bus (GNUNET_gstData *d)
+{
+  GstBus *bus;
+
+  bus = gst_element_get_bus (GST_ELEMENT (d->pipeline));
+  gst_bus_add_signal_watch (bus);
+  g_signal_connect (G_OBJECT (bus), "message::error", (GCallback) error_cb,
+                    d);
+  g_signal_connect (G_OBJECT (bus), "message::eos", (GCallback) eos_cb,
+                    d);
+  g_signal_connect (G_OBJECT (bus), "message::state-changed",
+                    (GCallback) state_changed_cb, d);
+  g_signal_connect (G_OBJECT (bus), "message::application",
+                    (GCallback) application_cb, d);
+  g_signal_connect (G_OBJECT (bus), "message::about-to-finish",
+                    (GCallback) application_cb, d);
+  gst_object_unref (bus);
+}
+
+
+/*
+ * take buffer from gstreamer and feed it to gnunet
+ */
+/*
+   extern int
+   feed_buffer_to_gnunet (GNUNET_gstData * d)
+   {
+   GstSample *s;
+   GstBuffer *b;
+   GstMapInfo m;
+   size_t len, msg_size;
+   const char *ptr;
+   int phase;
+
+   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "pulling...\n");
+   s = gst_app_sink_pull_sample (GST_APP_SINK(d->appsink));
+   if (NULL == s)
+   {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "pulled NULL\n");
+    return OK;
+   }
+   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "...pulled!\n");
+
+    const GstStructure *si;
+    char *si_str;
+    GstCaps *s_caps;
+    char *caps_str;
+    si = gst_sample_get_info (s);
+    if (si)
+    {
+      si_str = gst_structure_to_string (si);
+      if (si_str)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got sample %s\n", si_str);
+        g_free (si_str);
+      }
+    }
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got sample with no info\n");
+    s_caps = gst_sample_get_caps (s);
+    if (s_caps)
+    {
+      caps_str = gst_caps_to_string (s_caps);
+      if (caps_str)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got sample with caps %s\n", caps_str);
+        g_free (caps_str);
+      }
+    }
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got sample with no caps\n");
+
+   b = gst_sample_get_buffer (s);
+   if (NULL == b || !gst_buffer_map (b, &m, GST_MAP_READ))
+   {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "got NULL buffer %p or failed to map the buffer\n", b);
+    gst_sample_unref (s);
+    return FAIL;
+   }
+
+   len = m.size;
+   if (len > UINT16_MAX - sizeof (struct AudioMessage))
+   {
+    GNUNET_break (0);
+    len = UINT16_MAX - sizeof (struct AudioMessage);
+   }
+   msg_size = sizeof (struct AudioMessage) + len;
+   audio_message.header.size = htons ((uint16_t) msg_size);
+
+
+   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+      "Sending %u bytes of audio data\n", (unsigned int) msg_size);
+   for (phase = 0; phase < 2; phase++)
+   {
+    size_t offset;
+    size_t to_send;
+    ssize_t ret;
+    if (0 == phase && !d->pure_ogg)
+    {
+   //#ifdef DEBUG_RECORD_PURE_OGG
+
+   //      if (d->pure_ogg)
+   //        break;
+
+   //#endif
+      ptr = (const char *) &audio_message;
+      to_send = sizeof (audio_message);
+    }
+    else
+    {
+      ptr = (const char *) m.data;
+      to_send = len;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+        "Sending %u bytes on phase %d\n", (unsigned int) to_send, phase);
+    for (offset = 0; offset < to_send; offset += ret)
+    {
+      ret = write (1, &ptr[offset], to_send - offset);
+      if (0 >= ret)
+      {
+        if (-1 == ret)
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Failed to write %u bytes at offset %u (total %u) in phase %d: %s\n",
+              (unsigned int) to_send - offset, (unsigned int) offset,
+              (unsigned int) (to_send + offset), phase, strerror (errno));
+     //   abort_send = 1;
+        return FAIL;
+      }
+    }
+
+   //   if (abort_send)
+   //   break;
+
+   }
+   gst_buffer_unmap (b, &m);
+   gst_sample_unref (s);
+   }
+ */
+
+
+extern int
+feed_buffer_to_gst (const char *audio, size_t b_len, GNUNET_gstData *d)
+{
+  GstBuffer *b;
+  gchar *bufspace;
+  GstFlowReturn flow;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Feeding %u bytes to GStreamer\n",
+              (unsigned int) b_len);
+
+  bufspace = g_memdup (audio, b_len);
+  b = gst_buffer_new_wrapped (bufspace, b_len);
+  if (NULL == b)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Failed to wrap a buffer\n");
+    g_free (bufspace);
+    return GNUNET_SYSERR;
+  }
+  if (GST_APP_SRC (d->appsrc) == NULL)
+    exit (10);
+  flow = gst_app_src_push_buffer (GST_APP_SRC (d->appsrc), b);
+  /* They all return GNUNET_OK, because currently player stops when
+   * data stops coming. This might need to be changed for the player
+   * to also stop when pipeline breaks.
+   */
+  switch (flow)
+  {
+  case GST_FLOW_OK:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Fed %u bytes to the pipeline\n",
+                (unsigned int) b_len);
+    break;
+
+  case GST_FLOW_FLUSHING:
+    /* buffer was dropped, because pipeline state is not PAUSED or PLAYING */
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Dropped a buffer\n");
+    break;
+
+  case GST_FLOW_EOS:
+    /* end of stream */
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "EOS\n");
+    break;
+
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Unexpected push result\n");
+    break;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * debug making elements
+ */
+extern GstElement *
+gst_element_factory_make_debug (gchar *factoryname, gchar *name)
+{
+  GstElement *element;
+
+  element = gst_element_factory_make (factoryname, name);
+
+  if (element == NULL)
+  {
+    printf ("\n Failed to create element - type: %s name: %s \n", factoryname,
+            name);
+    exit (10);
+    return element;
+  }
+  else
+  {
+    return element;
+  }
+}
+
+
+/*
+   static gboolean
+   gst_element_link_many_debug(...)
+   {
+   va_list arguments;
+   gst_element_link_many(argptr);
+   }
+
+ #define gst_element_link_many(...) \
+           gst_element_link_many_debug(__VA_ARGS__)
+ */
+extern void
+lf (char *msg)
+{
+  printf ("linking elements failed: %s", msg);
+  exit (10);
+}
+
+
+/***
+ * used to set properties on autoaudiosink's chosen sink
+ */
+static void
+autoaudiosink_child_added (GstChildProxy *child_proxy,
+                           GObject *object,
+                           gchar *name,
+                           gpointer user_data)
+{
+  if (GST_IS_AUDIO_BASE_SRC (object))
+    g_object_set (object,
+                  "buffer-time", (gint64) BUFFER_TIME,
+                  "latency-time", (gint64) LATENCY_TIME,
+                  NULL);
+}
+
+
+/***
+ * used to set properties on autoaudiosource's chosen sink
+ */
+static void
+autoaudiosource_child_added (GstChildProxy *child_proxy, GObject *object,
+                             gchar *name, gpointer user_data)
+{
+  if (GST_IS_AUDIO_BASE_SRC (object))
+    g_object_set (object, "buffer-time", (gint64) BUFFER_TIME, "latency-time",
+                  (gint64) LATENCY_TIME, NULL);
+}
+
+
+GstElement *
+get_pipeline (GstElement *element)
+{
+  GstPipeline *p;
+
+  p = GST_PIPELINE (gst_object_get_parent (GST_OBJECT (element)));
+
+  return GST_ELEMENT (p);
+}
+
+
+static void
+decoder_ogg_pad_added (GstElement *element,
+                       GstPad *pad,
+                       gpointer data)
+{
+  GstPad *sinkpad;
+  GstElement *decoder = (GstElement *) data;
+
+  printf ("==== ogg pad added callback \n");
+  /* We can now link this pad with the opus-decoder sink pad */
+//  pl_graph(get_pipeline(element));
+  sinkpad = gst_element_get_static_pad (decoder, "sink");
+
+  gst_pad_link (pad, sinkpad);
+  gst_element_link_many (element, decoder, NULL);
+  gst_object_unref (sinkpad);
+}
+
+
+int
+gnunet_read (GNUNET_gstData *d)
+{
+  char readbuf[MAXLINE];
+  int ret;
+
+  printf ("read \n");
+  ret = read (0, readbuf, sizeof(readbuf));
+  if (0 > ret)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Read error from STDIN: %d %s\n"),
+                ret, strerror (errno));
+    return FAIL;
+  }
+  // toff += ret;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received %d bytes of audio data\n",
+              (int) ret);
+  if (0 == ret)
+    return FAIL;
+  // #ifdef DEBUG_READ_PURE_OGG
+
+  if (d->pure_ogg)
+  {
+    feed_buffer_to_gst (readbuf, ret, d);
+  }
+  else
+  {
+    // #endif
+    GNUNET_MST_from_buffer (d->stdin_mst,
+                            readbuf,
+                            ret,
+                            GNUNET_NO,
+                            GNUNET_NO);
+  }
+  return 0;
+}
+
+
+/**
+ * Message callback
+ *
+ * @param msg message we received.
+ * @return #GNUNET_OK on success,
+ *     #GNUNET_NO to stop further processing due to disconnect (no error)
+ *     #GNUNET_SYSERR to stop further processing due to error
+ */
+static int
+stdin_receiver (void *cls,
+                const struct GNUNET_MessageHeader *msg)
+{
+  struct AudioMessage *audio;
+  size_t b_len;
+
+  printf ("stdin receiver \n ");
+  dump_buffer (sizeof(msg),
+               (const unsigned char *) msg);
+
+  switch (ntohs (msg->type))
+  {
+  case GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO:
+    audio = (struct AudioMessage *) msg;
+
+    b_len = ntohs (audio->header.size) - sizeof(struct AudioMessage);
+    printf ("feeding buffer to gst \n ");
+    feed_buffer_to_gst ((const char *) &audio[1], b_len, cls);
+    break;
+
+  default:
+    printf ("No audio message: %u \n ", ntohs (msg->type));
+    break;
+  }
+  return GNUNET_OK;
+}
+
+
+GstBin *
+get_app (GNUNET_gstData *d, int type)
+{
+  GstBin *bin;
+  GstPad *pad, *ghostpad;
+
+  if (type == SOURCE)
+  {
+    bin = GST_BIN (gst_bin_new ("Gnunet appsrc"));
+
+
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_log_setup ("gnunet-helper-audio-playback",
+                                     "WARNING",
+                                     NULL));
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Audio playback starts\n");
+    printf (" creating appsrc \n ");
+    // d->audio_message.header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO);
+
+// d->audio_message = GNUNET_malloc (UINT16_MAX);
+//  d->audio_message = (AudioMessage*)malloc(sizeof(struct AudioMessage));
+//  d->audio_message = GNUNET_malloc(sizeof(struct AudioMessage));
+
+
+    // d->audio_message.header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO);
+
+
+    d->stdin_mst = GNUNET_MST_create (&stdin_receiver, d);
+
+    if (d->stdin_mst == NULL)
+      printf ("stdin_mst = NULL");
+
+    d->appsrc = gst_element_factory_make ("appsrc", "appsrc");
+
+    gst_bin_add_many (bin, d->appsrc, NULL);
+//    gst_element_link_many ( encoder, muxer, NULL);
+
+    pad = gst_element_get_static_pad (d->appsrc, "src");
+    ghostpad = gst_ghost_pad_new ("src", pad);
+  }
+  if (type == SINK)
+  {
+    bin = GST_BIN (gst_bin_new ("Gnunet appsink"));
+
+
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_log_setup ("gnunet-helper-audio-record",
+                                     "WARNING",
+                                     NULL));
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Audio source starts\n");
+
+    d->appsink = gst_element_factory_make ("appsink", "appsink");
+
+    // Move this out of here!
+    d->audio_message = GNUNET_malloc (UINT16_MAX);
+    (d->audio_message)->header.type = htons (
+      GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO);
+    g_object_set (G_OBJECT (d->appsink), "emit-signals", TRUE, "sync", TRUE,
+                  NULL);
+
+    g_signal_connect (d->appsink, "new-sample",
+                      G_CALLBACK (on_appsink_new_sample), &d);
+
+    gst_bin_add_many (bin, d->appsink, NULL);
+//    gst_element_link_many ( encoder, muxer, NULL);
+
+    pad = gst_element_get_static_pad (d->appsink, "sink");
+    ghostpad = gst_ghost_pad_new ("sink", pad);
+  }
+
+  /* set the bin pads */
+  gst_pad_set_active (ghostpad, TRUE);
+  gst_element_add_pad (GST_ELEMENT (bin), ghostpad);
+
+  gst_object_unref (pad);
+
+  return bin;
+}
+
+
+extern GstBin *
+get_coder (GNUNET_gstData *d, int type)
+{
+  GstBin *bin;
+  GstPad *srcpad, *sinkpad, *srcghostpad, *sinkghostpad;
+  GstCaps *rtpcaps;
+  GstElement *encoder, *muxer, *decoder, *demuxer, *jitterbuffer,
+             *rtpcapsfilter;
+
+  if (d->usertp == TRUE)
+  {
+    /*
+     * application/x-rtp, media=(string)audio, clock-rate=(int)48000, encoding-name=(string)OPUS, sprop-maxcapturerate=(string)48000, sprop-stereo=(string)0, payload=(int)96, encoding-params=(string)2, ssrc=(uint)630297634, timestamp-offset=(uint)678334141, seqnum-offset=(uint)16938 */
+/*
+    rtpcaps = gst_caps_new_simple ("application/x-rtp",
+          "media", G_TYPE_STRING, "audio",
+          "clock-rate", G_TYPE_INT, SAMPLING_RATE,
+          "encoding-name", G_TYPE_STRING, "OPUS",
+          "payload", G_TYPE_INT, 96,
+          "sprop-stereo", G_TYPE_STRING, "0",
+          "encoding-params", G_TYPE_STRING, "2",
+          NULL);
+ */ rtpcaps = gst_caps_new_simple ("application/x-rtp",
+                                   "media", G_TYPE_STRING, "audio",
+                                   "clock-rate", G_TYPE_INT, SAMPLING_RATE,
+                                   "encoding-name", G_TYPE_STRING, "OPUS",
+                                   "payload", G_TYPE_INT, 96,
+                                   "sprop-stereo", G_TYPE_STRING, "0",
+                                   "encoding-params", G_TYPE_STRING, "2",
+                                   NULL);
+
+
+    rtpcapsfilter = gst_element_factory_make ("capsfilter", "rtpcapsfilter");
+
+    g_object_set (G_OBJECT (rtpcapsfilter),
+                  "caps", rtpcaps,
+                  NULL);
+    gst_caps_unref (rtpcaps);
+  }
+
+
+  if (type == ENCODER)
+  {
+    bin = GST_BIN (gst_bin_new ("Gnunet audioencoder"));
+
+    encoder = gst_element_factory_make ("opusenc", "opus-encoder");
+    if (d->usertp == TRUE)
+    {
+      muxer = gst_element_factory_make ("rtpopuspay", "rtp-payloader");
+    }
+    else
+    {
+      muxer = gst_element_factory_make ("oggmux", "ogg-muxer");
+    }
+    g_object_set (G_OBJECT (encoder),
+                  /*      "bitrate", 64000, */
+                  /*      "bandwidth", OPUS_BANDWIDTH_FULLBAND, */
+                  "inband-fec", INBAND_FEC_MODE,
+                  "packet-loss-percentage", PACKET_LOSS_PERCENTAGE,
+                  "max-payload-size", MAX_PAYLOAD_SIZE,
+                  "audio", TRUE,  /* VoIP, not audio */
+                  "frame-size", OPUS_FRAME_SIZE,
+                  NULL);
+
+    if (d->usertp != TRUE)
+    {
+      g_object_set (G_OBJECT (muxer),
+                    "max-delay", OGG_MAX_DELAY,
+                    "max-page-delay", OGG_MAX_PAGE_DELAY,
+                    NULL);
+    }
+
+    gst_bin_add_many (bin, encoder, muxer, NULL);
+    gst_element_link_many (encoder, muxer, NULL);
+    sinkpad = gst_element_get_static_pad (encoder, "sink");
+    sinkghostpad = gst_ghost_pad_new ("sink", sinkpad);
+
+    srcpad = gst_element_get_static_pad (muxer, "src");
+    srcghostpad = gst_ghost_pad_new ("src", srcpad);
+  }
+  if (type == DECODER)
+  {
+    bin = GST_BIN (gst_bin_new ("Gnunet audiodecoder"));
+
+    // decoder
+    if (d->usertp == TRUE)
+    {
+      demuxer = gst_element_factory_make ("rtpopusdepay", "ogg-demuxer");
+      jitterbuffer = gst_element_factory_make ("rtpjitterbuffer",
+                                               "rtpjitterbuffer");
+    }
+    else
+    {
+      demuxer = gst_element_factory_make ("oggdemux", "ogg-demuxer");
+    }
+    decoder = gst_element_factory_make ("opusdec", "opus-decoder");
+
+    if (d->usertp == TRUE)
+    {
+      gst_bin_add_many (bin, rtpcapsfilter, jitterbuffer, demuxer, decoder,
+                        NULL);
+      gst_element_link_many (rtpcapsfilter, jitterbuffer, demuxer, decoder,
+                             NULL);
+      sinkpad = gst_element_get_static_pad (rtpcapsfilter, "sink");
+    }
+    else
+    {
+      gst_bin_add_many (bin, demuxer, decoder, NULL);
+
+      g_signal_connect (demuxer,
+                        "pad-added",
+                        G_CALLBACK (decoder_ogg_pad_added),
+                        decoder);
+
+      sinkpad = gst_element_get_static_pad (demuxer, "sink");
+    }
+    sinkghostpad = gst_ghost_pad_new ("sink", sinkpad);
+
+    srcpad = gst_element_get_static_pad (decoder, "src");
+    srcghostpad = gst_ghost_pad_new ("src", srcpad);
+  }
+
+  // add pads to the bin
+  gst_pad_set_active (sinkghostpad, TRUE);
+  gst_element_add_pad (GST_ELEMENT (bin), sinkghostpad);
+
+  gst_pad_set_active (srcghostpad, TRUE);
+  gst_element_add_pad (GST_ELEMENT (bin), srcghostpad);
+
+
+  return bin;
+}
+
+
+extern GstBin *
+get_audiobin (GNUNET_gstData *d, int type)
+{
+  GstBin *bin;
+  GstElement *sink, *source, *queue, *conv, *resampler, *removesilence, *filter;
+  GstPad *pad, *ghostpad;
+  GstCaps *caps;
+
+  if (type == SINK)
+  {
+    bin = GST_BIN (gst_bin_new ("Gnunet audiosink"));
+
+    /* Create all the elements */
+    if (d->dropsilence == TRUE)
+    {
+      queue = gst_element_factory_make ("queue", "queue");
+      removesilence = gst_element_factory_make ("removesilence",
+                                                "removesilence");
+    }
+
+    conv = gst_element_factory_make ("audioconvert", "converter");
+    resampler = gst_element_factory_make ("audioresample", "resampler");
+
+    if (d->audiobackend == AUTO)
+    {
+      sink = gst_element_factory_make ("autoaudiosink", "audiosink");
+      g_signal_connect (sink, "child-added", G_CALLBACK (
+                          autoaudiosink_child_added), NULL);
+    }
+
+    if (d->audiobackend == ALSA)
+    {
+      sink = gst_element_factory_make ("alsaaudiosink", "audiosink");
+    }
+
+    if (d->audiobackend == JACK)
+    {
+      sink = gst_element_factory_make ("jackaudiosink", "audiosink");
+
+      g_object_set (G_OBJECT (sink), "client-name", "gnunet", NULL);
+
+      if (g_object_class_find_property
+            (G_OBJECT_GET_CLASS (sink), "port-pattern"))
+      {
+//        char *portpattern = "system";
+
+        g_object_set (G_OBJECT (sink), "port-pattern", d->jack_pp_out,
+                      NULL);
+      }
+    }
+
+    if (d->audiobackend == FAKE)
+    {
+      sink = gst_element_factory_make ("fakesink", "audiosink");
+    }
+
+    g_object_set (sink,
+                  "buffer-time", (gint64) BUFFER_TIME,
+                  "latency-time", (gint64) LATENCY_TIME,
+                  NULL);
+
+    if (d->dropsilence == TRUE)
+    {
+      // Do not remove silence by default
+      g_object_set (removesilence, "remove", FALSE, NULL);
+      g_object_set (queue, "max-size-buffers", 12, NULL);
+      /*
+         g_signal_connect (source,
+         "need-data",
+         G_CALLBACK(appsrc_need_data),
+         NULL);
+
+         g_signal_connect (source,
+         "enough-data",
+         G_CALLBACK(appsrc_enough_data),
+         NULL);
+       *//*
+      g_signal_connect (queue,
+          "notify::current-level-bytes",
+          G_CALLBACK(queue_current_level),
+          NULL);
+
+      g_signal_connect (queue,
+          "underrun",
+          G_CALLBACK(queue_underrun),
+          NULL);
+
+      g_signal_connect (queue,
+          "running",
+          G_CALLBACK(queue_running),
+          NULL);
+
+      g_signal_connect (queue,
+          "overrun",
+          G_CALLBACK(queue_overrun),
+          NULL);
+
+      g_signal_connect (queue,
+          "pushing",
+          G_CALLBACK(queue_pushing),
+          NULL);
+ */ }
+
+
+    gst_bin_add_many (bin, conv, resampler, sink, NULL);
+    gst_element_link_many (conv, resampler, sink, NULL);
+
+    if (d->dropsilence == TRUE)
+    {
+      gst_bin_add_many (bin, queue, removesilence, NULL);
+
+      if (! gst_element_link_many (queue, removesilence, conv, NULL))
+        lf ("queue, removesilence, conv ");
+
+      pad = gst_element_get_static_pad (queue, "sink");
+    }
+    else
+    {
+      pad = gst_element_get_static_pad (conv, "sink");
+    }
+
+    ghostpad = gst_ghost_pad_new ("sink", pad);
+  }
+  else
+  {
+    // SOURCE
+
+    bin = GST_BIN (gst_bin_new ("Gnunet audiosource"));
+
+    //    source = gst_element_factory_make("audiotestsrc", "audiotestsrcbla");
+
+    if (d->audiobackend == AUTO)
+    {
+      source = gst_element_factory_make ("autoaudiosrc", "audiosource");
+    }
+    if (d->audiobackend == ALSA)
+    {
+      source = gst_element_factory_make ("alsasrc", "audiosource");
+    }
+    if (d->audiobackend == JACK)
+    {
+      source = gst_element_factory_make ("jackaudiosrc", "audiosource");
+    }
+    if (d->audiobackend == TEST)
+    {
+      source = gst_element_factory_make ("audiotestsrc", "audiosource");
+    }
+
+    filter = gst_element_factory_make ("capsfilter", "filter");
+    conv = gst_element_factory_make ("audioconvert", "converter");
+    resampler = gst_element_factory_make ("audioresample", "resampler");
+
+    if (d->audiobackend == AUTO)
+    {
+      g_signal_connect (source, "child-added", G_CALLBACK (
+                          autoaudiosource_child_added), NULL);
+    }
+    else
+    {
+      if (GST_IS_AUDIO_BASE_SRC (source))
+        g_object_set (source, "buffer-time", (gint64) BUFFER_TIME,
+                      "latency-time", (gint64) LATENCY_TIME, NULL);
+      if (d->audiobackend == JACK)
+      {
+        g_object_set (G_OBJECT (source), "client-name", "gnunet", NULL);
+        if (g_object_class_find_property
+              (G_OBJECT_GET_CLASS (source), "port-pattern"))
+        {
+          char *portpattern = "moc";
+
+          g_object_set (G_OBJECT (source), "port-pattern", portpattern,
+                        NULL);
+        }
+      }
+    }
+
+    caps = gst_caps_new_simple ("audio/x-raw",
+                                /*  "format", G_TYPE_STRING, "S16LE", */
+                                /*    "rate", G_TYPE_INT, SAMPLING_RATE,*/
+                                "channels", G_TYPE_INT, OPUS_CHANNELS,
+                                /*    "layout", G_TYPE_STRING, "interleaved",*/
+                                NULL);
+
+    g_object_set (G_OBJECT (filter),
+                  "caps", caps,
+                  NULL);
+    gst_caps_unref (caps);
+
+    gst_bin_add_many (bin, source, filter, conv, resampler, NULL);
+    gst_element_link_many (source, filter, conv, resampler, NULL);
+
+    pad = gst_element_get_static_pad (resampler, "src");
+
+
+    /* pads */
+    ghostpad = gst_ghost_pad_new ("src", pad);
+  }
+
+  /* set the bin pads */
+  gst_pad_set_active (ghostpad, TRUE);
+  gst_element_add_pad (GST_ELEMENT (bin), ghostpad);
+
+  gst_object_unref (pad);
+
+  return bin;
+}
diff --git a/src/contrib/service/conversation/gnunet_gst.h b/src/contrib/service/conversation/gnunet_gst.h
new file mode 100644
index 000000000..479ae14b3
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet_gst.h
@@ -0,0 +1,62 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 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 conversation/gnunet_gst.c
+ * @brief FIXME
+ * @author Hark
+ */
+
+// which audiobackend we use
+//
+
+/*
+   int audiobackend = JACK;
+   int dropsilence = TRUE;
+   int enough = 0;
+   int usertp = TRUE;
+ */
+
+#define gst_element_factory_make(element, name) gst_element_factory_make_debug ( \
+    element, name);
+
+extern void pl_graph ();
+
+
+extern GstElement *
+gst_element_factory_make_debug (gchar *, gchar *);
+
+extern GstBin *
+get_audiobin (GNUNET_gstData *, int);
+
+extern GstBin *
+get_coder (GNUNET_gstData *, int);
+
+
+extern gboolean
+gnunet_gst_bus_call (GstBus *bus, GstMessage *msg, gpointer data);
+
+extern void
+gg_setup_gst_bus (GNUNET_gstData *d);
+
+extern void
+gg_load_configuration (GNUNET_gstData *d);
+
+extern GstFlowReturn
+on_appsink_new_sample (GstElement *, GNUNET_gstData *);
diff --git a/src/contrib/service/conversation/gnunet_gst_def.h b/src/contrib/service/conversation/gnunet_gst_def.h
new file mode 100644
index 000000000..7bfcc5e53
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet_gst_def.h
@@ -0,0 +1,219 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 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 conversation/gnunet_gst_def.h
+ * @brief FIXME
+ * @author Hark
+ */
+
+#include <getopt.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+#include <regex.h>
+
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+// #include "gnunet/conversation.h" doesn't get installed
+#include "conversation.h"
+#include "gnunet_constants.h"
+#include "gnunet_core_service.h"
+#include "gnunet_common.h"
+
+/*
+ #include <gst/gst.h>
+ #include <gst/audio/gstaudiobasesrc.h>
+ #include <gst/app/gstappsrc.h>
+ */
+
+/* huh
+ #include <glib-2.0/glib.h>
+
+ #include <gstreamer-1.0/gst/gst.h>
+ #include <gstreamer-1.0/gst/pbutils/pbutils.h>
+ #include <gstreamer-1.0/gst/video/videooverlay.h>
+ #include <gstreamer-1.0/gst/audio/gstaudiobasesrc.h>
+ #include <gstreamer-1.0/gst/app/gstappsrc.h>
+ */
+
+#include <gst/gst.h>
+#include <gst/audio/gstaudiobasesrc.h>
+#include <gst/app/gstappsrc.h>
+#include <glib.h>
+#include <gst/app/gstappsink.h>
+
+// sockets
+#if HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#include <sys/types.h>
+#include <fcntl.h>
+
+
+// glib stuff
+// #include <glib.h>
+#include <glib-2.0/glib/gprintf.h>
+// #include <glib-unix.h>
+
+// static struct AudioMessage *audio_message;
+
+
+typedef struct GNUNET_gstData GNUNET_gstData;
+struct GNUNET_gstData
+{
+  // general
+  GstPipeline *pipeline;
+
+  // things
+  struct AudioMessage *audio_message;
+  struct GNUNET_MessageStreamTokenizer *stdin_mst;
+  GstElement *appsrc;
+  GstElement *appsink;
+  // settings
+  int audiobackend;
+  int dropsilence;
+  int usertp;
+  int pure_ogg;
+  char *jack_pp_in;
+  char *jack_pp_out;
+};
+
+
+#define DEBUG_READ_PURE_OGG 1
+#define DEBUG_RECORD_PURE_OGG 1
+
+
+/**
+ * How much data to read in one go
+ */
+#define MAXLINE 4096
+
+/**
+ * Max number of microseconds to buffer in audiosink.
+ * Default is 1000
+ */
+#define BUFFER_TIME 1000
+
+/**
+ * Min number of microseconds to buffer in audiosink.
+ * Default is 1000
+ */
+#define LATENCY_TIME 1000
+
+
+/**
+ * Number of channels.
+ * Must be one of the following (from libopusenc documentation):
+ * 1, 2
+ */
+#define OPUS_CHANNELS 1
+
+/**
+ * Maximal size of a single opus packet.
+ */
+#define MAX_PAYLOAD_SIZE (1024 / OPUS_CHANNELS)
+
+/**
+ * Size of a single frame fed to the encoder, in ms.
+ * Must be one of the following (from libopus documentation):
+ * 2.5, 5, 10, 20, 40 or 60
+ */
+#define OPUS_FRAME_SIZE 40
+
+/**
+ * Expected packet loss to prepare for, in percents.
+ */
+#define PACKET_LOSS_PERCENTAGE 1
+
+/**
+ * Set to 1 to enable forward error correction.
+ * Set to 0 to disable.
+ */
+#define INBAND_FEC_MODE 1
+
+/**
+ * Max number of microseconds to buffer in audiosource.
+ * Default is 200000
+ */
+#define BUFFER_TIME 1000 /* 1ms */
+
+/**
+ * Min number of microseconds to buffer in audiosource.
+ * Default is 10000
+ */
+#define LATENCY_TIME 1000 /* 1ms */
+
+/**
+ * Maximum delay in multiplexing streams, in ns.
+ * Setting this to 0 forces page flushing, which
+ * decreases delay, but increases overhead.
+ */
+#define OGG_MAX_DELAY 0
+
+/**
+ * Maximum delay for sending out a page, in ns.
+ * Setting this to 0 forces page flushing, which
+ * decreases delay, but increases overhead.
+ */
+#define OGG_MAX_PAGE_DELAY 0
+
+#define SAMPLING_RATE 48000
+
+enum
+{
+  AUTO,
+  JACK,
+  ALSA,
+  FAKE,
+  TEST
+};
+
+enum
+{
+  SOURCE,
+  SINK
+};
+
+enum
+{
+  ENCODER,
+  DECODER
+};
+
+enum
+{
+  FAIL,
+  OK
+};
+
+enum
+{
+  SPEAKER,
+  MICROPHONE
+};
diff --git a/src/contrib/service/conversation/gnunet_gst_test.c b/src/contrib/service/conversation/gnunet_gst_test.c
new file mode 100644
index 000000000..dd2ef5a38
--- /dev/null
+++ b/src/contrib/service/conversation/gnunet_gst_test.c
@@ -0,0 +1,135 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 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 conversation/gnunet_gst_test.c
+ * @brief FIXME
+ * @author Hark
+ */
+
+#include "platform.h"
+#include "gnunet_gst_def.h"
+#include "gnunet_gst.h"
+
+int
+main (int argc, char *argv[])
+{
+  struct GNUNET_gstData *gst;
+  // GstBus *bus;
+  GstElement *gnunetsrc, *gnunetsink, *source, *sink, *encoder, *decoder;
+
+
+  // audio_message = GNUNET_malloc (UINT16_MAX);
+  // audio_message->header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO);
+
+
+  // GstPipeline *pipeline;
+
+  gst = (GNUNET_gstData *) malloc (sizeof(struct GNUNET_gstData));
+
+  // gst->audio_message.header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO);
+
+
+  gg_load_configuration (gst);
+/*
+   gst->audiobackend = JACK;
+   gst->dropsilence = TRUE;
+   gst->usertp = FALSE;
+ *//* Initialize GStreamer */gst_init (&argc, &argv);
+
+  gst->pipeline = GST_PIPELINE (gst_pipeline_new ("gnunet-media-helper"));
+
+#ifdef IS_SPEAKER
+  int type = SPEAKER;
+  printf ("this is the speaker \n");
+#endif
+#ifdef IS_MIC
+  int type = MICROPHONE;
+  printf ("this is the microphone \n");
+#endif
+  if (type == SPEAKER)
+  {
+    gnunetsrc = GST_ELEMENT (get_app (gst, SOURCE));
+
+    sink = GST_ELEMENT (get_audiobin (gst, SINK));
+    decoder = GST_ELEMENT (get_coder (gst, DECODER));
+    gst_bin_add_many (GST_BIN (gst->pipeline), gnunetsrc, decoder, sink, NULL);
+    gst_element_link_many (gnunetsrc, decoder, sink, NULL);
+  }
+  if (type == MICROPHONE)
+  {
+    source = GST_ELEMENT (get_audiobin (gst, SOURCE));
+
+    encoder = GST_ELEMENT (get_coder (gst, ENCODER));
+
+    gnunetsink = GST_ELEMENT (get_app (gst, SINK));
+
+    gst_bin_add_many (GST_BIN (gst->pipeline), source, encoder, gnunetsink,
+                      NULL);
+    gst_element_link_many (source, encoder, gnunetsink, NULL);
+  }
+  /*
+     gst_bin_add_many( GST_BIN(gst->pipeline), appsource, appsink, source, encoder, decoder, sink, NULL);
+     gst_element_link_many( source, encoder, decoder, sink , NULL);
+   */
+  pl_graph (gst->pipeline);
+  /* Start playing */
+  gst_element_set_state (GST_ELEMENT (gst->pipeline), GST_STATE_PLAYING);
+
+  // pl_graph(gst->pipeline);
+
+  /* Wait until error or EOS */
+  // bus = gst_element_get_bus (GST_ELEMENT(gst->pipeline));
+  // bus_watch_id = gst_bus_add_watch (bus, gnunet_gst_bus_call, pipeline);
+
+  gg_setup_gst_bus (gst);
+// g_print ("Running...\n");
+
+
+  // start pushing buffers
+  if (type == MICROPHONE)
+  {
+    GMainLoop *loop;
+    loop = g_main_loop_new (NULL, FALSE);
+
+    g_main_loop_run (loop);
+
+/*
+   while ( 1 )
+     {
+         GstFlowReturn flow;
+         flow = on_appsink_new_sample (gst->appsink, gst);
+    }
+ */}
+  if (type == SPEAKER)
+  {
+    while (1)
+    {
+//      printf("read.. \n");
+      gnunet_read (gst);
+    }
+  }
+  g_print ("Returned, stopping playback\n");
+
+  // gst_object_unref (bus);
+  gst_element_set_state (GST_ELEMENT (gst->pipeline), GST_STATE_NULL);
+  gst_object_unref (gst->pipeline);
+
+  return 0;
+}
diff --git a/src/contrib/service/conversation/mediahelper.conf b/src/contrib/service/conversation/mediahelper.conf
new file mode 100644
index 000000000..85c051107
--- /dev/null
+++ b/src/contrib/service/conversation/mediahelper.conf
@@ -0,0 +1,7 @@
+[MEDIAHELPER]
+AUDIOBACKEND = JACK
+REMOVESILENCE = NO
+USERTP  = NO
+NO_GN_HEADERS = NO
+JACK_PP_IN = mocp
+JACK_PP_OUT = system
diff --git a/src/contrib/service/conversation/meson.build b/src/contrib/service/conversation/meson.build
new file mode 100644
index 000000000..4ecc0fc93
--- /dev/null
+++ b/src/contrib/service/conversation/meson.build
@@ -0,0 +1,203 @@
+libgnunetconversation_src = ['conversation_api.c', 'conversation_api_call.c']
+
+gnunetserviceconversation_src = ['gnunet-service-conversation.c']
+
+gnunetconversationproxy_src = ['gnunet-conversation-proxy.c']
+
+configure_file(input : 'conversation.conf.in',
+               output : 'conversation.conf',
+               configuration : cdata,
+               install: true,
+               install_dir: pkgcfgdir)
+
+
+if get_option('monolith')
+  foreach p : libgnunetconversation_src + gnunetserviceconversation_src
+    gnunet_src += 'conversation/' + p
+  endforeach
+endif
+
+libgnunetmicrophone = library('gnunetmicrophone',
+        ['microphone.c'],
+        soversion: '0',
+        version: '0.0.0',
+        dependencies: [libgnunetutil_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir'))
+libgnunetmicrophone_dep = declare_dependency(link_with : libgnunetmicrophone)
+pkg.generate(libgnunetmicrophone, url: 'https://www.gnunet.org',
+             description : 'Provides API to access to microphone')
+
+libgnunetspeaker = library('gnunetspeaker',
+        ['speaker.c'],
+        soversion: '0',
+        version: '0.0.0',
+        dependencies: [libgnunetutil_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir'))
+libgnunetspeaker_dep = declare_dependency(link_with : libgnunetspeaker)
+pkg.generate(libgnunetspeaker, url: 'https://www.gnunet.org',
+             description : 'Provides API to access to speaker')
+
+libgnunetconversation = library('gnunetconversation',
+        libgnunetconversation_src,
+        soversion: '0',
+        version: '0.0.0',
+        dependencies: [libgnunetutil_dep,
+                       libgnunetgnsrecord_dep,
+                       libgnunetgns_dep,
+                       libgnunetnamestore_dep,
+                       libgnunetidentity_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir'))
+libgnunetconversation_dep = declare_dependency(link_with : libgnunetconversation)
+pkg.generate(libgnunetconversation, url: 'https://www.gnunet.org',
+             description : 'Provides API to access to conversation')
+
+shared_module('gnunet_plugin_gnsrecord_conversation',
+        ['plugin_gnsrecord_conversation.c'],
+        dependencies: [libgnunetutil_dep,
+                       libgnunetconversation_dep,
+                       libgnunetgns_dep,
+                       libgnunetgnsrecord_dep,
+                       libgnunetidentity_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir')/'gnunet')
+
+executable ('gnunet-conversation',
+            'gnunet-conversation.c',
+            dependencies: [libgnunetconversation_dep,
+                           libgnunetgns_dep,
+                           libgnunetgnsrecord_dep,
+                           libgnunetnamestore_dep,
+                           libgnunetspeaker_dep,
+                           libgnunetmicrophone_dep,
+                           libgnunetidentity_dep,
+                           libgnunetutil_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('bindir'))
+
+executable ('gnunet-conversation-test',
+            'gnunet-conversation-test.c',
+            dependencies: [libgnunetconversation_dep,
+                           libgnunetspeaker_dep,
+                           libgnunetmicrophone_dep,
+                           libgnunetutil_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('bindir'))
+
+executable ('gnunet-service-conversation',
+            gnunetserviceconversation_src,
+            dependencies: [libgnunetconversation_dep,
+                           libgnunetutil_dep,
+                           libgnunetspeaker_dep,
+                           libgnunetmicrophone_dep,
+                           libgnunetidentity_dep,
+                           libgnunetcadet_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+
+helperrecord_src = ['gnunet-helper-audio-record.c']
+helperplayback_src = ['gnunet-helper-audio-record.c']
+if conversation_backend == 'gst'
+  helperrecord_src = ['gnunet-helper-audio-record-gst.c']
+  helperplayback_src = ['gnunet-helper-audio-playback-gst.c']
+endif
+
+executable ('gnunet-helper-audio-record',
+            helperrecord_src,
+            dependencies: [libgnunetconversation_dep,
+                           libgnunetutil_dep,
+                           libgnunetspeaker_dep,
+                           libgnunetmicrophone_dep,
+                           gst_dep,
+                           gst_app_dep,
+                           gst_audio_dep,
+                           ogg_dep,
+                           pulse_dep,
+                           opus_dep
+                           ],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+
+executable ('gnunet-helper-audio-playback',
+         helperplayback_src,
+          dependencies: [libgnunetconversation_dep,
+                         libgnunetutil_dep,
+                         libgnunetspeaker_dep,
+                         libgnunetmicrophone_dep,
+                         gst_dep,
+                         gst_app_dep,
+                         gst_audio_dep,
+                         ogg_dep,
+                         pulse_dep,
+                         opus_dep
+                         ],
+          include_directories: [incdir, configuration_inc],
+          install: true,
+          install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+
+testconvapi = executable ('test_conversation_api',
+         ['test_conversation_api.c'],
+          dependencies: [libgnunetconversation_dep,
+                         libgnunetutil_dep,
+                         libgnunetidentity_dep,
+                         libgnunettesting_dep,
+                         libgnunetgnsrecord_dep,
+                         libgnunetnamestore_dep,
+                         libgnunetspeaker_dep,
+                         libgnunetmicrophone_dep,
+                         ],
+          include_directories: [incdir, configuration_inc],
+          install: false)
+
+testconvapitwo = executable ('test_conversation_api_twocalls',
+         ['test_conversation_api_twocalls.c'],
+          dependencies: [libgnunetconversation_dep,
+                         libgnunetutil_dep,
+                         libgnunetidentity_dep,
+                         libgnunettesting_dep,
+                         libgnunetgnsrecord_dep,
+                         libgnunetnamestore_dep,
+                         libgnunetspeaker_dep,
+                         libgnunetmicrophone_dep,
+                         ],
+          include_directories: [incdir, configuration_inc],
+          install: false)
+
+testconvapireject = executable ('test_conversation_api_reject',
+         ['test_conversation_api_reject.c'],
+          dependencies: [libgnunetconversation_dep,
+                         libgnunetutil_dep,
+                         libgnunetidentity_dep,
+                         libgnunettesting_dep,
+                         libgnunetgnsrecord_dep,
+                         libgnunetnamestore_dep,
+                         libgnunetspeaker_dep,
+                         libgnunetmicrophone_dep,
+                         ],
+          include_directories: [incdir, configuration_inc],
+          install: false)
+
+configure_file(input : 'test_conversation.conf',
+               output : 'test_conversation.conf',
+               copy: true,
+               install: false)
+
+test('test_conversation_api', testconvapi, workdir: meson.current_build_dir(),
+     suite: ['conversation', 'contrib'])
+
+test('test_conversation_api_twocalls', testconvapitwo, workdir: meson.current_build_dir(),
+     suite: ['conversation', 'contrib'])
+
+test('test_conversation_api_reject', testconvapireject, workdir: meson.current_build_dir(),
+     suite: ['conversation', 'contrib'])
+
diff --git a/src/contrib/service/conversation/microphone.c b/src/contrib/service/conversation/microphone.c
new file mode 100644
index 000000000..a4a40796f
--- /dev/null
+++ b/src/contrib/service/conversation/microphone.c
@@ -0,0 +1,200 @@
+/*
+   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 conversation/microphone.c
+ * @brief API to access an audio microphone; provides access to hardware microphones;
+ *        actually just wraps the gnunet-helper-audio-record
+ * @author Simon Dieterle
+ * @author Andreas Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_microphone_lib.h"
+#include "conversation.h"
+
+
+/**
+ * Internal data structures for the microphone.
+ */
+struct Microphone
+{
+  /**
+   * Our configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Handle for the record helper
+   */
+  struct GNUNET_HELPER_Handle *record_helper;
+
+  /**
+   * Function to call with audio data (if we are enabled).
+   */
+  GNUNET_MICROPHONE_RecordedDataCallback rdc;
+
+  /**
+   * Closure for @e rdc.
+   */
+  void *rdc_cls;
+};
+
+
+/**
+ * Function to process the audio from the record helper
+ *
+ * @param cls clsoure with our `struct Microphone`
+ * @param msg the message from the helper
+ * @return #GNUNET_OK on success,
+ *    #GNUNET_NO to stop further processing (no error)
+ *    #GNUNET_SYSERR to stop further processing with error
+ */
+static int
+process_record_messages (void *cls,
+                         const struct GNUNET_MessageHeader *msg)
+{
+  struct Microphone *mic = cls;
+  const struct AudioMessage *am;
+
+  if (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  am = (const struct AudioMessage *) msg;
+  mic->rdc (mic->rdc_cls,
+            ntohs (msg->size) - sizeof(struct AudioMessage),
+            &am[1]);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Enable a microphone.
+ *
+ * @param cls clsoure with our `struct Microphone`
+ * @param rdc function to call with recorded data
+ * @param rdc_cls closure for @a dc
+ */
+static int
+enable (void *cls,
+        GNUNET_MICROPHONE_RecordedDataCallback rdc,
+        void *rdc_cls)
+{
+  struct Microphone *mic = cls;
+  static char *const record_helper_argv[] = {
+    "gnunet-helper-audio-record",
+    NULL
+  };
+
+  mic->rdc = rdc;
+  mic->rdc_cls = rdc_cls;
+  mic->record_helper = GNUNET_HELPER_start (GNUNET_NO,
+                                            "gnunet-helper-audio-record",
+                                            record_helper_argv,
+                                            &process_record_messages,
+                                            NULL, mic);
+  if (NULL == mic->record_helper)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Could not start record audio helper\n"));
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function that disables a microphone.
+ *
+ * @param cls clsoure
+ */
+static void
+disable (void *cls)
+{
+  struct Microphone *mic = cls;
+
+  if (NULL == mic->record_helper)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_HELPER_kill (mic->record_helper, GNUNET_NO));
+  GNUNET_HELPER_destroy (mic->record_helper);
+  mic->record_helper = NULL;
+}
+
+
+/**
+ * Function to destroy a microphone.
+ *
+ * @param cls clsoure
+ */
+static void
+destroy (void *cls)
+{
+  struct Microphone *mic = cls;
+
+  if (NULL != mic->record_helper)
+    disable (mic);
+}
+
+
+/**
+ * Create a microphone that corresponds to the microphone hardware
+ * of our system.
+ *
+ * @param cfg configuration to use
+ * @return NULL on error
+ */
+struct GNUNET_MICROPHONE_Handle *
+GNUNET_MICROPHONE_create_from_hardware (const struct
+                                        GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_MICROPHONE_Handle *microphone;
+  struct Microphone *mic;
+
+  mic = GNUNET_new (struct Microphone);
+  mic->cfg = cfg;
+  microphone = GNUNET_new (struct GNUNET_MICROPHONE_Handle);
+  microphone->cls = mic;
+  microphone->enable_microphone = &enable;
+  microphone->disable_microphone = &disable;
+  microphone->destroy_microphone = &destroy;
+  return microphone;
+}
+
+
+/**
+ * Destroy a microphone.
+ *
+ * @param microphone microphone to destroy
+ */
+void
+GNUNET_MICROPHONE_destroy (struct GNUNET_MICROPHONE_Handle *microphone)
+{
+  microphone->destroy_microphone (microphone->cls);
+  GNUNET_free (microphone);
+}
+
+
+/* end of microphone.c */
diff --git a/src/contrib/service/conversation/plugin_gnsrecord_conversation.c b/src/contrib/service/conversation/plugin_gnsrecord_conversation.c
new file mode 100644
index 000000000..802732cfe
--- /dev/null
+++ b/src/contrib/service/conversation/plugin_gnsrecord_conversation.c
@@ -0,0 +1,262 @@
+/*
+     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 conversation/plugin_gnsrecord_conversation.c
+ * @brief gnsrecord plugin to provide the API for fundamental GNS records
+ *                  This includes the VPN record because GNS resolution
+ *                  is expected to understand VPN records and (if needed)
+ *                  map the result to A/AAAA.
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_gnsrecord_lib.h"
+#include "gnunet_conversation_service.h"
+#include "gnunet_gnsrecord_plugin.h"
+
+
+/**
+ * Convert the 'value' of a record to a string.
+ *
+ * @param cls closure, unused
+ * @param type type of the record
+ * @param data value in binary encoding
+ * @param data_size number of bytes in @a data
+ * @return NULL on error, otherwise human-readable representation of the value
+ */
+static char *
+conversation_value_to_string (void *cls,
+                              uint32_t type,
+                              const void *data,
+                              size_t data_size)
+{
+  char *s;
+
+  (void) cls;
+  switch (type)
+  {
+  case GNUNET_GNSRECORD_TYPE_PHONE:
+    {
+      const struct GNUNET_CONVERSATION_PhoneRecord *pr;
+      char *ret;
+      char *pkey;
+
+      if (data_size != sizeof(struct GNUNET_CONVERSATION_PhoneRecord))
+      {
+        GNUNET_break_op (0);
+        return NULL;
+      }
+      pr = data;
+      if (1 != ntohl (pr->version))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("PHONE version %u not supported\n"),
+                    ntohl (pr->version));
+        return NULL;
+      }
+      pkey = GNUNET_CRYPTO_eddsa_public_key_to_string (&pr->peer.public_key);
+      s = GNUNET_STRINGS_data_to_string_alloc (&pr->line_port,
+                                               sizeof(struct GNUNET_HashCode));
+
+      GNUNET_asprintf (&ret,
+                       "%s-%s",
+                       s,
+                       pkey);
+      GNUNET_free (s);
+      GNUNET_free (pkey);
+      return ret;
+    }
+
+  default:
+    return NULL;
+  }
+}
+
+
+/**
+ * Convert human-readable version of a 'value' of a record to the binary
+ * representation.
+ *
+ * @param cls closure, unused
+ * @param type type of the record
+ * @param s human-readable string
+ * @param data set to value in binary encoding (will be allocated)
+ * @param data_size set to number of bytes in @a data
+ * @return #GNUNET_OK on success
+ */
+static int
+conversation_string_to_value (void *cls,
+                              uint32_t type,
+                              const char *s,
+                              void **data,
+                              size_t *data_size)
+{
+  (void) cls;
+  if (NULL == s)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  switch (type)
+  {
+  case GNUNET_GNSRECORD_TYPE_PHONE:
+    {
+      struct GNUNET_CONVERSATION_PhoneRecord *pr;
+      char line_port[104];
+      const char *dash;
+      struct GNUNET_PeerIdentity peer;
+
+      if ((NULL == (dash = strchr (s, '-'))) ||
+          (1 != sscanf (s, "%103s-", line_port)) ||
+          (GNUNET_OK !=
+           GNUNET_CRYPTO_eddsa_public_key_from_string (dash + 1,
+                                                       strlen (dash + 1),
+                                                       &peer.public_key)))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("Unable to parse PHONE record `%s'\n"),
+                    s);
+        return GNUNET_SYSERR;
+      }
+      pr = GNUNET_new (struct GNUNET_CONVERSATION_PhoneRecord);
+      pr->version = htonl (1);
+      pr->reserved = htonl (0);
+      if (GNUNET_OK !=
+          GNUNET_STRINGS_string_to_data (line_port,
+                                         strlen (line_port),
+                                         &pr->line_port,
+                                         sizeof(struct GNUNET_HashCode)))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _ ("Unable to parse PHONE record `%s'\n"),
+                    s);
+        GNUNET_free (pr);
+        return GNUNET_SYSERR;
+      }
+      pr->peer = peer;
+      *data = pr;
+      *data_size = sizeof(struct GNUNET_CONVERSATION_PhoneRecord);
+      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[] = {
+  { "PHONE", GNUNET_GNSRECORD_TYPE_PHONE },
+  { 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
+conversation_typename_to_number (void *cls,
+                                 const char *gns_typename)
+{
+  unsigned int i;
+
+  (void) cls;
+  i = 0;
+  while ((name_map[i].name != NULL) &&
+         (0 != strcasecmp (gns_typename, name_map[i].name)))
+    i++;
+  return name_map[i].number;
+}
+
+
+/**
+ * Convert a type number to the corresponding type string (e.g. 1 to "A")
+ *
+ * @param cls closure, unused
+ * @param type number of a type to convert
+ * @return corresponding typestring, NULL on error
+ */
+static const char *
+conversation_number_to_typename (void *cls,
+                                 uint32_t type)
+{
+  unsigned int i;
+
+  (void) cls;
+  i = 0;
+  while ((name_map[i].name != NULL) &&
+         (type != name_map[i].number))
+    i++;
+  return name_map[i].name;
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls NULL
+ * @return the exported block API
+ */
+void *
+libgnunet_plugin_gnsrecord_conversation_init (void *cls)
+{
+  struct GNUNET_GNSRECORD_PluginFunctions *api;
+
+  (void) cls;
+  api = GNUNET_new (struct GNUNET_GNSRECORD_PluginFunctions);
+  api->value_to_string = &conversation_value_to_string;
+  api->string_to_value = &conversation_string_to_value;
+  api->typename_to_number = &conversation_typename_to_number;
+  api->number_to_typename = &conversation_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_conversation_done (void *cls)
+{
+  struct GNUNET_GNSRECORD_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_gnsrecord_conversation.c */
diff --git a/src/contrib/service/conversation/speaker.c b/src/contrib/service/conversation/speaker.c
new file mode 100644
index 000000000..38eb1159c
--- /dev/null
+++ b/src/contrib/service/conversation/speaker.c
@@ -0,0 +1,189 @@
+/*
+   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 conversation/speaker.c
+ * @brief API to access an audio speaker; provides access to hardware speakers
+ * @author Simon Dieterle
+ * @author Andreas Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_speaker_lib.h"
+#include "conversation.h"
+
+
+/**
+ * Internal data structures for the speaker.
+ */
+struct Speaker
+{
+  /**
+   * Our configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Handle for the playback helper
+   */
+  struct GNUNET_HELPER_Handle *playback_helper;
+};
+
+
+/**
+ * Function that enables a speaker.
+ *
+ * @param cls closure with the `struct Speaker`
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+static int
+enable (void *cls)
+{
+  struct Speaker *spe = cls;
+  static char *playback_helper_argv[] = {
+    "gnunet-helper-audio-playback",
+    NULL
+  };
+
+  spe->playback_helper = GNUNET_HELPER_start (GNUNET_NO,
+                                              "gnunet-helper-audio-playback",
+                                              playback_helper_argv,
+                                              NULL,
+                                              NULL, spe);
+  if (NULL == spe->playback_helper)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Could not start playback audio helper.\n"));
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function that disables a speaker.
+ *
+ * @param cls closure with the `struct Speaker`
+ */
+static void
+disable (void *cls)
+{
+  struct Speaker *spe = cls;
+
+  if (NULL == spe->playback_helper)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_HELPER_kill (spe->playback_helper, GNUNET_NO));
+  GNUNET_HELPER_destroy (spe->playback_helper);
+  spe->playback_helper = NULL;
+}
+
+
+/**
+ * Function to destroy a speaker.
+ *
+ * @param cls closure with the `struct Speaker`
+ */
+static void
+destroy (void *cls)
+{
+  struct Speaker *spe = cls;
+
+  if (NULL != spe->playback_helper)
+    disable (spe);
+}
+
+
+/**
+ * Function to cause a speaker to play audio data.
+ *
+ * @param cls clsoure with the `struct Speaker`
+ * @param data_size number of bytes in @a data
+ * @param data audio data to play, format is
+ *        opaque to the API but should be OPUS.
+ */
+static void
+play (void *cls,
+      size_t data_size,
+      const void *data)
+{
+  struct Speaker *spe = cls;
+  char buf[sizeof(struct AudioMessage) + data_size];
+  struct AudioMessage *am;
+
+  if (NULL == spe->playback_helper)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  am = (struct AudioMessage *) buf;
+  am->header.size = htons (sizeof(struct AudioMessage) + data_size);
+  am->header.type = htons (GNUNET_MESSAGE_TYPE_CONVERSATION_AUDIO);
+  GNUNET_memcpy (&am[1], data, data_size);
+  (void) GNUNET_HELPER_send (spe->playback_helper,
+                             &am->header,
+                             GNUNET_NO,
+                             NULL, NULL);
+}
+
+
+/**
+ * Create a speaker that corresponds to the speaker hardware
+ * of our system.
+ *
+ * @param cfg configuration to use
+ * @return NULL on error
+ */
+struct GNUNET_SPEAKER_Handle *
+GNUNET_SPEAKER_create_from_hardware (const struct
+                                     GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_SPEAKER_Handle *speaker;
+  struct Speaker *spe;
+
+  spe = GNUNET_new (struct Speaker);
+  spe->cfg = cfg;
+  speaker = GNUNET_new (struct GNUNET_SPEAKER_Handle);
+  speaker->cls = spe;
+  speaker->enable_speaker = &enable;
+  speaker->play = &play;
+  speaker->disable_speaker = &disable;
+  speaker->destroy_speaker = &destroy;
+  return speaker;
+}
+
+
+/**
+ * Destroy a speaker.
+ *
+ * @param speaker speaker to destroy
+ */
+void
+GNUNET_SPEAKER_destroy (struct GNUNET_SPEAKER_Handle *speaker)
+{
+  speaker->destroy_speaker (speaker->cls);
+  GNUNET_free (speaker);
+}
+
+
+/* end of speaker.c */
diff --git a/src/contrib/service/conversation/test.sh b/src/contrib/service/conversation/test.sh
new file mode 100644
index 000000000..20e82bc88
--- /dev/null
+++ b/src/contrib/service/conversation/test.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+export GST_DEBUG_DUMP_DOT_DIR=/tmp/ 
+GST_DEBUG_DUMP_DOT_DIR=/tmp/ ./gnunet-helper-audio-record |GST_DEBUG_DUMP_DOT_DIR=/tmp/ ./gnunet-helper-audio-playback
diff --git a/src/contrib/service/conversation/test_conversation.conf b/src/contrib/service/conversation/test_conversation.conf
new file mode 100644
index 000000000..097aed592
--- /dev/null
+++ b/src/contrib/service/conversation/test_conversation.conf
@@ -0,0 +1,12 @@
+@INLINE@ ../../../../contrib/conf/gnunet/no_forcestart.conf
+
+[conversation]
+LINE=1
+#PREFIX = valgrind
+
+[zonemaster]
+IMMEDIATE_START = YES
+START_ON_DEMAND = YES
+
+[nse]
+WORKBITS = 0
diff --git a/src/contrib/service/conversation/test_conversation_api.c b/src/contrib/service/conversation/test_conversation_api.c
new file mode 100644
index 000000000..decc40b64
--- /dev/null
+++ b/src/contrib/service/conversation/test_conversation_api.c
@@ -0,0 +1,510 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013, 2014, 2018 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file conversation/test_conversation_api.c
+ * @brief testcase for conversation_api.c
+ *
+ * This test performs the operations of a call to a phone
+ * where the phone user picks up and then the call is
+ * terminated by the party that initiated the call.
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_gnsrecord_lib.h"
+#include "gnunet_conversation_service.h"
+#include "gnunet_identity_service.h"
+#include "gnunet_namestore_service.h"
+
+#define FREQ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)
+
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 25)
+
+static int ok = 1;
+
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+static struct GNUNET_IDENTITY_Handle *id;
+
+static struct GNUNET_IDENTITY_Operation *op;
+
+static struct GNUNET_CONVERSATION_Phone *phone;
+
+static struct GNUNET_NAMESTORE_Handle *ns;
+
+static struct GNUNET_CONVERSATION_Call *call;
+
+static struct GNUNET_NAMESTORE_QueueEntry *qe;
+
+static struct GNUNET_CONVERSATION_Caller *active_caller;
+
+static char *gns_name;
+
+static char *gns_caller_id;
+
+static GNUNET_MICROPHONE_RecordedDataCallback phone_rdc;
+
+static void *phone_rdc_cls;
+
+static GNUNET_MICROPHONE_RecordedDataCallback call_rdc;
+
+static void *call_rdc_cls;
+
+static struct GNUNET_SCHEDULER_Task *phone_task;
+
+static struct GNUNET_SCHEDULER_Task *call_task;
+
+
+static void
+phone_send (void *cls)
+{
+  static unsigned int i;
+  char buf[32];
+
+  (void) cls;
+  GNUNET_assert (NULL != phone_rdc);
+  GNUNET_snprintf (buf, sizeof(buf), "phone-%u", i++);
+  phone_rdc (phone_rdc_cls, strlen (buf) + 1, buf);
+  phone_task = GNUNET_SCHEDULER_add_delayed (FREQ, &phone_send, NULL);
+}
+
+
+static void
+call_send (void *cls)
+{
+  static unsigned int i;
+  char buf[32];
+
+  (void) cls;
+  GNUNET_assert (NULL != call_rdc);
+  GNUNET_snprintf (buf, sizeof(buf), "call-%u", i++);
+  call_rdc (call_rdc_cls, strlen (buf) + 1, buf);
+  call_task = GNUNET_SCHEDULER_add_delayed (FREQ, &call_send, NULL);
+}
+
+
+static int
+enable_speaker (void *cls)
+{
+  const char *origin = cls;
+
+  fprintf (stderr, "Speaker %s enabled\n", origin);
+  return GNUNET_OK;
+}
+
+
+static void
+disable_speaker (void *cls)
+{
+  const char *origin = cls;
+
+  fprintf (stderr, "Speaker %s disabled\n", origin);
+}
+
+
+static void
+play (void *cls, size_t data_size, const void *data)
+{
+  const char *origin = cls;
+  static unsigned int phone_i = 1;
+  static unsigned int call_i;
+  char buf[32];
+
+  if (0 == strcmp (origin, "phone"))
+    GNUNET_snprintf (buf, sizeof(buf), "call-%u", call_i++);
+  else
+    GNUNET_snprintf (buf, sizeof(buf), "phone-%u", phone_i++);
+  if ((data_size != strlen (buf) + 1) || (0 != strncmp (buf, data, data_size)))
+  {
+    fprintf (stderr,
+             "Expected %s, received %.*s\n",
+             buf,
+             (int) data_size,
+             (const char *) data);
+  }
+  else
+  {
+    fprintf (stderr, ".");
+  }
+  if ((20 < call_i) && (20 < phone_i) && (NULL != call))
+  {
+    /* time to hang up ... */
+    GNUNET_CONVERSATION_call_stop (call);
+    call = NULL;
+  }
+}
+
+
+static void
+destroy_speaker (void *cls)
+{
+  const char *origin = cls;
+
+  fprintf (stderr, "Speaker %s destroyed\n", origin);
+}
+
+
+static struct GNUNET_SPEAKER_Handle call_speaker = { &enable_speaker,
+                                                     &play,
+                                                     &disable_speaker,
+                                                     &destroy_speaker,
+                                                     "caller" };
+
+
+static struct GNUNET_SPEAKER_Handle phone_speaker = { &enable_speaker,
+                                                      &play,
+                                                      &disable_speaker,
+                                                      &destroy_speaker,
+                                                      "phone" };
+
+
+static int
+enable_mic (void *cls,
+            GNUNET_MICROPHONE_RecordedDataCallback rdc,
+            void *rdc_cls)
+{
+  const char *origin = cls;
+
+  fprintf (stderr, "Mic %s enabled\n", origin);
+  if (0 == strcmp (origin, "phone"))
+  {
+    phone_rdc = rdc;
+    phone_rdc_cls = rdc_cls;
+    phone_task = GNUNET_SCHEDULER_add_now (&phone_send, NULL);
+  }
+  else
+  {
+    call_rdc = rdc;
+    call_rdc_cls = rdc_cls;
+    call_task = GNUNET_SCHEDULER_add_now (&call_send, NULL);
+  }
+  return GNUNET_OK;
+}
+
+
+static void
+disable_mic (void *cls)
+{
+  const char *origin = cls;
+
+  fprintf (stderr, "Mic %s disabled\n", origin);
+  if (0 == strcmp (origin, "phone"))
+  {
+    phone_rdc = NULL;
+    phone_rdc_cls = NULL;
+    GNUNET_SCHEDULER_cancel (phone_task);
+    phone_task = NULL;
+  }
+  else
+  {
+    call_rdc = NULL;
+    call_rdc_cls = NULL;
+    GNUNET_SCHEDULER_cancel (call_task);
+    call_task = NULL;
+  }
+}
+
+
+static void
+destroy_mic (void *cls)
+{
+  const char *origin = cls;
+
+  fprintf (stderr, "Mic %s destroyed\n", origin);
+}
+
+
+static struct GNUNET_MICROPHONE_Handle call_mic = { &enable_mic,
+                                                    &disable_mic,
+                                                    &destroy_mic,
+                                                    "caller" };
+
+
+static struct GNUNET_MICROPHONE_Handle phone_mic = { &enable_mic,
+                                                     &disable_mic,
+                                                     &destroy_mic,
+                                                     "phone" };
+
+
+/**
+ * Signature of the main function of a task.
+ *
+ * @param cls closure
+ */
+static void
+end_test (void *cls)
+{
+  (void) cls;
+  GNUNET_SCHEDULER_shutdown ();
+  if (NULL != op)
+  {
+    GNUNET_IDENTITY_cancel (op);
+    op = NULL;
+  }
+  if (NULL != call)
+  {
+    GNUNET_CONVERSATION_call_stop (call);
+    call = NULL;
+  }
+  if (NULL != phone)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from PHONE service.\n");
+    GNUNET_CONVERSATION_phone_destroy (phone);
+    phone = NULL;
+  }
+  if (NULL != id)
+  {
+    GNUNET_IDENTITY_disconnect (id);
+    id = NULL;
+  }
+  if (NULL != qe)
+  {
+    GNUNET_NAMESTORE_cancel (qe);
+    qe = NULL;
+  }
+  if (NULL != ns)
+  {
+    GNUNET_NAMESTORE_disconnect (ns);
+    ns = NULL;
+  }
+}
+
+
+static void
+caller_event_handler (void *cls, enum GNUNET_CONVERSATION_CallerEventCode code)
+{
+  (void) cls;
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_CALLER_SUSPEND:
+  case GNUNET_CONVERSATION_EC_CALLER_RESUME:
+    fprintf (stderr, "Unexpected caller code: %d\n", code);
+    break;
+  }
+}
+
+
+static void
+phone_event_handler (void *cls,
+                     enum GNUNET_CONVERSATION_PhoneEventCode code,
+                     struct GNUNET_CONVERSATION_Caller *caller,
+                     const struct GNUNET_CRYPTO_PublicKey *caller_id)
+{
+  static enum GNUNET_CONVERSATION_PhoneEventCode expect =
+    GNUNET_CONVERSATION_EC_PHONE_RING;
+
+  (void) cls;
+  (void) caller_id;
+  GNUNET_break (code == expect);
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_PHONE_RING:
+    active_caller = caller;
+    GNUNET_CONVERSATION_caller_pick_up (caller,
+                                        &caller_event_handler,
+                                        NULL,
+                                        &phone_speaker,
+                                        &phone_mic);
+    expect = GNUNET_CONVERSATION_EC_PHONE_HUNG_UP;
+    break;
+
+  case GNUNET_CONVERSATION_EC_PHONE_HUNG_UP:
+    GNUNET_break (caller == active_caller);
+    active_caller = NULL;
+    if (1 == ok)
+      ok = 0;
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  default:
+    fprintf (stderr, "Unexpected phone code: %d\n", code);
+    break;
+  }
+}
+
+
+static void
+call_event_handler (void *cls, enum GNUNET_CONVERSATION_CallEventCode code)
+{
+  static enum GNUNET_CONVERSATION_CallEventCode expect =
+    GNUNET_CONVERSATION_EC_CALL_RINGING;
+
+  (void) cls;
+  GNUNET_break (code == expect);
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_CALL_RINGING:
+    expect = GNUNET_CONVERSATION_EC_CALL_PICKED_UP;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_PICKED_UP:
+    expect = -1;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL:
+  case GNUNET_CONVERSATION_EC_CALL_HUNG_UP:
+    call = NULL;
+    ok = 2;
+    GNUNET_break (0);
+    fprintf (stderr, "Unexpected call code: %d\n", code);
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_SUSPENDED:
+  case GNUNET_CONVERSATION_EC_CALL_RESUMED:
+    GNUNET_break (0);
+    fprintf (stderr, "Unexpected call code: %d\n", code);
+    ok = 2;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_ERROR:
+    GNUNET_break (0);
+    fprintf (stderr, "Unexpected call code: %d\n", code);
+    call = NULL;
+    ok = 2;
+    break;
+  }
+}
+
+
+static void
+caller_ego_create_cont (void *cls,
+                        const struct GNUNET_CRYPTO_PrivateKey *pk,
+                        enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  op = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+}
+
+
+static void
+namestore_put_cont (void *cls, enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  qe = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+  GNUNET_assert (NULL == op);
+  op = GNUNET_IDENTITY_create (id, "caller-ego", NULL,
+                               GNUNET_PUBLIC_KEY_TYPE_ECDSA,
+                               &caller_ego_create_cont,
+                               NULL);
+}
+
+
+static void
+identity_cb (void *cls,
+             struct GNUNET_IDENTITY_Ego *ego,
+             void **ctx,
+             const char *name)
+{
+  struct GNUNET_GNSRECORD_Data rd;
+  struct GNUNET_CRYPTO_PublicKey pub;
+
+  (void) cls;
+  (void) ctx;
+  if (NULL == name)
+    return;
+  if (NULL == ego)
+    return;
+  if (0 == strcmp (name, "phone-ego"))
+  {
+    GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
+    GNUNET_asprintf (&gns_name,
+                     "phone.%s",
+                     GNUNET_GNSRECORD_pkey_to_zkey (&pub));
+    phone =
+      GNUNET_CONVERSATION_phone_create (cfg, ego, &phone_event_handler, NULL);
+    GNUNET_assert (NULL != phone);
+    memset (&rd, 0, sizeof(rd));
+    GNUNET_CONVERSATION_phone_get_record (phone, &rd);
+    GNUNET_assert (rd.record_type == GNUNET_GNSRECORD_TYPE_PHONE);
+    rd.expiration_time = UINT64_MAX;
+    qe =
+      GNUNET_NAMESTORE_record_set_store (ns,
+                                      GNUNET_IDENTITY_ego_get_private_key (ego),
+                                      "phone" /* GNS label */,
+                                      1,
+                                      &rd,
+                                      &namestore_put_cont,
+                                      NULL);
+    return;
+  }
+  if (0 == strcmp (name, "caller-ego"))
+  {
+    GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
+    GNUNET_asprintf (&gns_caller_id,
+                     "%s",
+                     GNUNET_GNSRECORD_pkey_to_zkey (&pub));
+    call = GNUNET_CONVERSATION_call_start (cfg,
+                                           ego,
+                                           gns_name,
+                                           &call_speaker,
+                                           &call_mic,
+                                           &call_event_handler,
+                                           NULL);
+    return;
+  }
+}
+
+
+static void
+phone_ego_create_cont (void *cls,
+                       const struct GNUNET_CRYPTO_PrivateKey *pk,
+                       enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  op = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+}
+
+
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_TESTING_Peer *peer)
+{
+  (void) cls;
+  (void) peer;
+  cfg = c;
+  GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_test, NULL);
+  id = GNUNET_IDENTITY_connect (cfg, &identity_cb, NULL);
+  op = GNUNET_IDENTITY_create (id, "phone-ego", NULL,
+                               GNUNET_PUBLIC_KEY_TYPE_ECDSA,
+                               &phone_ego_create_cont,
+                               NULL);
+  ns = GNUNET_NAMESTORE_connect (cfg);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  (void) argc;
+  (void) argv;
+  if (0 != GNUNET_TESTING_peer_run ("test_conversation_api",
+                                    "test_conversation.conf",
+                                    &run,
+                                    NULL))
+    return 1;
+  return ok;
+}
+
+
+/* end of test_conversation_api.c */
diff --git a/src/contrib/service/conversation/test_conversation_api_reject.c b/src/contrib/service/conversation/test_conversation_api_reject.c
new file mode 100644
index 000000000..248c7835d
--- /dev/null
+++ b/src/contrib/service/conversation/test_conversation_api_reject.c
@@ -0,0 +1,363 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013, 2014, 2018 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file conversation/test_conversation_api_reject.c
+ * @brief testcase for conversation_api.c
+ *
+ * This test performs the operations of a call to a phone
+ * where the phone user immediately hangs up (rejecting the
+ * call).
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_gnsrecord_lib.h"
+#include "gnunet_conversation_service.h"
+#include "gnunet_identity_service.h"
+#include "gnunet_namestore_service.h"
+
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 25)
+
+static int ok = 1;
+
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+static struct GNUNET_IDENTITY_Handle *id;
+
+static struct GNUNET_IDENTITY_Operation *op;
+
+static struct GNUNET_CONVERSATION_Phone *phone;
+
+static struct GNUNET_NAMESTORE_Handle *ns;
+
+static struct GNUNET_CONVERSATION_Call *call;
+
+static struct GNUNET_NAMESTORE_QueueEntry *qe;
+
+static char *gns_name;
+
+static char *gns_caller_id;
+
+
+static int
+enable_speaker (void *cls)
+{
+  (void) cls;
+  GNUNET_break (0);
+  return GNUNET_SYSERR;
+}
+
+
+static void
+disable_speaker (void *cls)
+{
+  (void) cls;
+  GNUNET_break (0);
+}
+
+
+static void
+play (void *cls, size_t data_size, const void *data)
+{
+  (void) cls;
+  (void) data_size;
+  (void) data;
+  GNUNET_break (0);
+}
+
+
+static void
+destroy_speaker (void *cls)
+{
+  (void) cls;
+}
+
+
+static struct GNUNET_SPEAKER_Handle call_speaker = { &enable_speaker,
+                                                     &play,
+                                                     &disable_speaker,
+                                                     &destroy_speaker,
+                                                     "caller" };
+
+
+static int
+enable_mic (void *cls,
+            GNUNET_MICROPHONE_RecordedDataCallback rdc,
+            void *rdc_cls)
+{
+  (void) cls;
+  (void) rdc;
+  (void) rdc_cls;
+  GNUNET_break (0);
+  return GNUNET_SYSERR;
+}
+
+
+static void
+disable_mic (void *cls)
+{
+  (void) cls;
+  GNUNET_break (0);
+}
+
+
+static void
+destroy_mic (void *cls)
+{
+  (void) cls;
+}
+
+
+static struct GNUNET_MICROPHONE_Handle call_mic = { &enable_mic,
+                                                    &disable_mic,
+                                                    &destroy_mic,
+                                                    "caller" };
+
+
+/**
+ * Signature of the main function of a task.
+ *
+ * @param cls closure
+ */
+static void
+end_test (void *cls)
+{
+  (void) cls;
+  GNUNET_SCHEDULER_shutdown ();
+  if (NULL != op)
+  {
+    GNUNET_IDENTITY_cancel (op);
+    op = NULL;
+  }
+  if (NULL != call)
+  {
+    GNUNET_CONVERSATION_call_stop (call);
+    call = NULL;
+  }
+  if (NULL != phone)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from PHONE service.\n");
+    GNUNET_CONVERSATION_phone_destroy (phone);
+    phone = NULL;
+  }
+  if (NULL != id)
+  {
+    GNUNET_IDENTITY_disconnect (id);
+    id = NULL;
+  }
+  if (NULL != qe)
+  {
+    GNUNET_NAMESTORE_cancel (qe);
+    qe = NULL;
+  }
+  if (NULL != ns)
+  {
+    GNUNET_NAMESTORE_disconnect (ns);
+    ns = NULL;
+  }
+}
+
+
+static void
+phone_event_handler (void *cls,
+                     enum GNUNET_CONVERSATION_PhoneEventCode code,
+                     struct GNUNET_CONVERSATION_Caller *caller,
+                     const struct GNUNET_CRYPTO_PublicKey *caller_id)
+{
+  static enum GNUNET_CONVERSATION_PhoneEventCode expect =
+    GNUNET_CONVERSATION_EC_PHONE_RING;
+
+  (void) cls;
+  (void) caller_id;
+  GNUNET_break (code == expect);
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_PHONE_RING:
+    GNUNET_CONVERSATION_caller_hang_up (caller);
+    break;
+
+  default:
+    fprintf (stderr, "Unexpected phone code: %d\n", code);
+    break;
+  }
+}
+
+
+static void
+call_event_handler (void *cls, enum GNUNET_CONVERSATION_CallEventCode code)
+{
+  static enum GNUNET_CONVERSATION_CallEventCode expect =
+    GNUNET_CONVERSATION_EC_CALL_RINGING;
+
+  (void) cls;
+  GNUNET_break (code == expect);
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_CALL_RINGING:
+    expect = GNUNET_CONVERSATION_EC_CALL_HUNG_UP;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_HUNG_UP:
+    call = NULL;
+    ok = 0;
+    GNUNET_SCHEDULER_shutdown ();
+    expect = -1;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_PICKED_UP:
+  case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL:
+  case GNUNET_CONVERSATION_EC_CALL_SUSPENDED:
+  case GNUNET_CONVERSATION_EC_CALL_RESUMED:
+    fprintf (stderr, "Unexpected call code: %d\n", code);
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_ERROR:
+    fprintf (stderr, "Unexpected call code: %d\n", code);
+    call = NULL;
+    break;
+  }
+}
+
+
+static void
+caller_ego_create_cont (void *cls,
+                        const struct GNUNET_CRYPTO_PrivateKey *pk,
+                        enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  op = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+}
+
+
+static void
+namestore_put_cont (void *cls, enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  qe = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+  GNUNET_assert (NULL == op);
+  op = GNUNET_IDENTITY_create (id, "caller-ego", NULL,
+                               GNUNET_PUBLIC_KEY_TYPE_ECDSA,
+                               &caller_ego_create_cont,
+                               NULL);
+}
+
+
+static void
+identity_cb (void *cls,
+             struct GNUNET_IDENTITY_Ego *ego,
+             void **ctx,
+             const char *name)
+{
+  struct GNUNET_GNSRECORD_Data rd;
+  struct GNUNET_CRYPTO_PublicKey pub;
+
+  (void) cls;
+  (void) ctx;
+  if (NULL == name)
+    return;
+  if (NULL == ego)
+    return;
+  if (0 == strcmp (name, "phone-ego"))
+  {
+    GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
+    GNUNET_asprintf (&gns_name,
+                     "phone.%s",
+                     GNUNET_GNSRECORD_pkey_to_zkey (&pub));
+    phone =
+      GNUNET_CONVERSATION_phone_create (cfg, ego, &phone_event_handler, NULL);
+    GNUNET_assert (NULL != phone);
+    memset (&rd, 0, sizeof(rd));
+    GNUNET_CONVERSATION_phone_get_record (phone, &rd);
+    GNUNET_assert (rd.record_type == GNUNET_GNSRECORD_TYPE_PHONE);
+    rd.expiration_time = UINT64_MAX;
+    qe =
+      GNUNET_NAMESTORE_record_set_store (ns,
+                                      GNUNET_IDENTITY_ego_get_private_key (ego),
+                                      "phone" /* GNS label */,
+                                      1,
+                                      &rd,
+                                      &namestore_put_cont,
+                                      NULL);
+    return;
+  }
+  if (0 == strcmp (name, "caller-ego"))
+  {
+    GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
+    GNUNET_asprintf (&gns_caller_id,
+                     "%s",
+                     GNUNET_GNSRECORD_pkey_to_zkey (&pub));
+    call = GNUNET_CONVERSATION_call_start (cfg,
+                                           ego,
+                                           gns_name,
+                                           &call_speaker,
+                                           &call_mic,
+                                           &call_event_handler,
+                                           NULL);
+    return;
+  }
+}
+
+
+static void
+phone_ego_create_cont (void *cls,
+                       const struct GNUNET_CRYPTO_PrivateKey *pk,
+                       enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  op = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+}
+
+
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_TESTING_Peer *peer)
+{
+  (void) cls;
+  (void) peer;
+  cfg = c;
+  GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_test, NULL);
+  id = GNUNET_IDENTITY_connect (cfg, &identity_cb, NULL);
+  op = GNUNET_IDENTITY_create (id, "phone-ego", NULL,
+                               GNUNET_PUBLIC_KEY_TYPE_ECDSA,
+                               &phone_ego_create_cont,
+                               NULL);
+  ns = GNUNET_NAMESTORE_connect (cfg);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  (void) argc;
+  (void) argv;
+  if (0 != GNUNET_TESTING_peer_run ("test_conversation_api",
+                                    "test_conversation.conf",
+                                    &run,
+                                    NULL))
+    return 1;
+  return ok;
+}
+
+
+/* end of test_conversation_api_reject.c */
diff --git a/src/contrib/service/conversation/test_conversation_api_twocalls.c b/src/contrib/service/conversation/test_conversation_api_twocalls.c
new file mode 100644
index 000000000..cc4969e09
--- /dev/null
+++ b/src/contrib/service/conversation/test_conversation_api_twocalls.c
@@ -0,0 +1,642 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013, 2018x 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 conversation/test_conversation_api_twocalls.c
+ * @brief testcase for conversation_api.c
+ *
+ * This test performs the operations of TWO calls made to a phone
+ * where the phone user picks up one, suspends it, picks up the
+ * second one; eventually, the initiator hangs up, the callee
+ * resumes the first call, and then the initiator hangs up the
+ * second call.
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_gnsrecord_lib.h"
+#include "gnunet_conversation_service.h"
+#include "gnunet_identity_service.h"
+#include "gnunet_namestore_service.h"
+
+#define FREQ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)
+
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 25)
+
+#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
+
+#define LOG_DEBUG(...) GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
+
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+static struct GNUNET_IDENTITY_Handle *id;
+
+static struct GNUNET_IDENTITY_Operation *op;
+
+static struct GNUNET_CONVERSATION_Phone *phone;
+
+static struct GNUNET_NAMESTORE_Handle *ns;
+
+static struct GNUNET_CONVERSATION_Call *call1;
+
+static struct GNUNET_CONVERSATION_Call *call2;
+
+static struct GNUNET_NAMESTORE_QueueEntry *qe;
+
+static struct GNUNET_CONVERSATION_Caller *active_caller1;
+
+static struct GNUNET_CONVERSATION_Caller *active_caller2;
+
+static char *gns_name;
+
+static char *gns_caller_id;
+
+static GNUNET_MICROPHONE_RecordedDataCallback phone_rdc;
+
+static void *phone_rdc_cls;
+
+static struct GNUNET_SCHEDULER_Task *phone_task;
+
+static struct GNUNET_SCHEDULER_Task *timeout_task;
+
+/**
+ * Variable for recognizing caller1
+ */
+static const char *caller1 = "caller1";
+
+/**
+ * Variable for recognizing caller2
+ */
+static const char *caller2 = "caller2";
+
+/**
+ * Variable for recognizing callee
+ */
+static const char *phone0 = "phone";
+
+
+#define CALLER1 &caller1
+#define CALLER2 &caller2
+#define PHONE0 &phone0
+
+#define CLS_STR(caller) (*((char **) caller))
+
+
+/**
+ * Did caller1 call finish successfully
+ */
+static int call1_finished;
+
+/**
+ * Did caller2 call finish successfully
+ */
+static int call2_finished;
+
+struct MicContext
+{
+  GNUNET_MICROPHONE_RecordedDataCallback rdc;
+
+  void *rdc_cls;
+
+  struct GNUNET_SCHEDULER_Task *call_task;
+};
+
+static struct MicContext call1_mic_ctx;
+static struct MicContext call2_mic_ctx;
+// static struct MicContext phone_mic_ctx;
+
+
+static void
+phone_send (void *cls)
+{
+  char buf[32];
+
+  (void) cls;
+  GNUNET_assert (NULL != phone_rdc);
+  GNUNET_snprintf (buf, sizeof(buf), "phone");
+  phone_rdc (phone_rdc_cls, strlen (buf) + 1, buf);
+  phone_task = GNUNET_SCHEDULER_add_delayed (FREQ, &phone_send, NULL);
+}
+
+
+static void
+call_send (void *cls)
+{
+  struct MicContext *mc = cls;
+  char buf[32];
+
+  (void) cls;
+  GNUNET_assert (NULL != mc->rdc);
+  GNUNET_snprintf (buf, sizeof(buf), "call");
+  mc->rdc (mc->rdc_cls, strlen (buf) + 1, buf);
+  mc->call_task = GNUNET_SCHEDULER_add_delayed (FREQ, &call_send, mc);
+}
+
+
+static int
+enable_speaker (void *cls)
+{
+  const char *origin = CLS_STR (cls);
+
+  (void) cls;
+  LOG_DEBUG ("Speaker %s enabled\n", origin);
+  return GNUNET_OK;
+}
+
+
+static void
+disable_speaker (void *cls)
+{
+  const char *origin = CLS_STR (cls);
+
+  (void) cls;
+  LOG_DEBUG ("Speaker %s disabled\n", origin);
+}
+
+
+static void
+play (void *cls, size_t data_size, const void *data)
+{
+  static unsigned int phone_i;
+  static unsigned int call_i;
+
+  (void) cls;
+  if (0 == strncmp ("call", data, data_size))
+    call_i++;
+  else if (0 == strncmp ("phone", data, data_size))
+    phone_i++;
+  else
+  {
+    LOG_DEBUG ("Received %u bytes of unexpected data `%.*s'\n",
+               (unsigned int) data_size,
+               (int) data_size,
+               (const char *) data);
+  }
+
+  if ((20 < call_i) && (20 < phone_i) && (CALLER2 == cls))
+  {
+    /* time to hang up ... */
+    GNUNET_CONVERSATION_call_stop (call2);
+    call2 = NULL;
+    /* reset counters */
+    call_i = 0;
+    phone_i = 0;
+    call2_finished = GNUNET_YES;
+  }
+  if ((20 < call_i) && (20 < phone_i) && (CALLER1 == cls))
+  {
+    /* time to hang up ... */
+    GNUNET_CONVERSATION_call_stop (call1);
+    call1 = NULL;
+    call_i = 0;
+    phone_i = 0;
+    call1_finished = GNUNET_YES;
+  }
+}
+
+
+static void
+destroy_speaker (void *cls)
+{
+  const char *origin = CLS_STR (cls);
+
+  LOG_DEBUG ("Speaker %s destroyed\n", origin);
+}
+
+
+static struct GNUNET_SPEAKER_Handle call1_speaker = { &enable_speaker,
+                                                      &play,
+                                                      &disable_speaker,
+                                                      &destroy_speaker,
+                                                      CALLER1 };
+
+
+static struct GNUNET_SPEAKER_Handle call2_speaker = { &enable_speaker,
+                                                      &play,
+                                                      &disable_speaker,
+                                                      &destroy_speaker,
+                                                      CALLER2 };
+
+
+static struct GNUNET_SPEAKER_Handle phone_speaker = { &enable_speaker,
+                                                      &play,
+                                                      &disable_speaker,
+                                                      &destroy_speaker,
+                                                      PHONE0 };
+
+
+static int
+enable_mic (void *cls,
+            GNUNET_MICROPHONE_RecordedDataCallback rdc,
+            void *rdc_cls)
+{
+  const char *origin = CLS_STR (cls);
+  struct MicContext *mc;
+
+  LOG_DEBUG ("Mic %s enabled\n", origin);
+  if (PHONE0 == cls)
+  {
+    phone_rdc = rdc;
+    phone_rdc_cls = rdc_cls;
+    GNUNET_break (NULL == phone_task);
+    phone_task = GNUNET_SCHEDULER_add_now (&phone_send, NULL);
+    return GNUNET_OK;
+  }
+  mc = (CALLER1 == cls) ? &call1_mic_ctx : &call2_mic_ctx;
+  mc->rdc = rdc;
+  mc->rdc_cls = rdc_cls;
+  GNUNET_break (NULL == mc->call_task);
+  mc->call_task = GNUNET_SCHEDULER_add_now (&call_send, mc);
+  return GNUNET_OK;
+}
+
+
+static void
+disable_mic (void *cls)
+{
+  const char *origin = CLS_STR (cls);
+  struct MicContext *mc;
+
+  LOG_DEBUG ("Mic %s disabled\n", origin);
+  if (PHONE0 == cls)
+  {
+    phone_rdc = NULL;
+    phone_rdc_cls = NULL;
+    GNUNET_SCHEDULER_cancel (phone_task);
+    phone_task = NULL;
+    return;
+  }
+  mc = (CALLER1 == cls) ? &call1_mic_ctx : &call2_mic_ctx;
+  mc->rdc = NULL;
+  mc->rdc_cls = NULL;
+  GNUNET_SCHEDULER_cancel (mc->call_task);
+  mc->call_task = NULL;
+}
+
+
+static void
+destroy_mic (void *cls)
+{
+  const char *origin = CLS_STR (cls);
+
+  LOG_DEBUG ("Mic %s destroyed\n", origin);
+}
+
+
+static struct GNUNET_MICROPHONE_Handle call1_mic = { &enable_mic,
+                                                     &disable_mic,
+                                                     &destroy_mic,
+                                                     CALLER1 };
+
+
+static struct GNUNET_MICROPHONE_Handle call2_mic = { &enable_mic,
+                                                     &disable_mic,
+                                                     &destroy_mic,
+                                                     CALLER2 };
+
+
+static struct GNUNET_MICROPHONE_Handle phone_mic = { &enable_mic,
+                                                     &disable_mic,
+                                                     &destroy_mic,
+                                                     PHONE0 };
+
+
+/**
+ * Function run on timeout.
+ *
+ * @param cls closure
+ */
+static void
+end_test (void *cls)
+{
+  (void) cls;
+  timeout_task = NULL;
+  fprintf (stderr, "Timeout!\n");
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * Function run on shutdown.
+ *
+ * @param cls closure
+ */
+static void
+do_shutdown (void *cls)
+{
+  (void) cls;
+  if (NULL != timeout_task)
+  {
+    GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = NULL;
+  }
+  if (NULL != op)
+  {
+    GNUNET_IDENTITY_cancel (op);
+    op = NULL;
+  }
+  if (NULL != call1)
+  {
+    GNUNET_CONVERSATION_call_stop (call1);
+    call1 = NULL;
+  }
+  if (NULL != call2)
+  {
+    GNUNET_CONVERSATION_call_stop (call2);
+    call2 = NULL;
+  }
+  if (NULL != phone)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from PHONE service.\n");
+    GNUNET_CONVERSATION_phone_destroy (phone);
+    phone = NULL;
+  }
+  if (NULL != id)
+  {
+    GNUNET_IDENTITY_disconnect (id);
+    id = NULL;
+  }
+  if (NULL != qe)
+  {
+    GNUNET_NAMESTORE_cancel (qe);
+    qe = NULL;
+  }
+  if (NULL != ns)
+  {
+    GNUNET_NAMESTORE_disconnect (ns);
+    ns = NULL;
+  }
+}
+
+
+static void
+caller_event_handler (void *cls, enum GNUNET_CONVERSATION_CallerEventCode code)
+{
+  (void) cls;
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_CALLER_SUSPEND:
+  case GNUNET_CONVERSATION_EC_CALLER_RESUME:
+    LOG (GNUNET_ERROR_TYPE_WARNING, "Unexpected caller code: %d\n", code);
+    break;
+  }
+}
+
+
+static void
+phone_event_handler (void *cls,
+                     enum GNUNET_CONVERSATION_PhoneEventCode code,
+                     struct GNUNET_CONVERSATION_Caller *caller,
+                     const struct GNUNET_CRYPTO_PublicKey *caller_id)
+{
+  const char *cid;
+
+  (void) cls;
+  (void) caller_id;
+
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_PHONE_RING:
+    if (NULL == active_caller1)
+    {
+      active_caller1 = caller;
+      cid = "caller1";
+      GNUNET_CONVERSATION_caller_pick_up (caller,
+                                          &caller_event_handler,
+                                          (void *) cid,
+                                          &phone_speaker,
+                                          &phone_mic);
+    }
+    else
+    {
+      GNUNET_CONVERSATION_caller_suspend (active_caller1);
+      active_caller2 = caller;
+      cid = "caller2";
+      GNUNET_CONVERSATION_caller_pick_up (caller,
+                                          &caller_event_handler,
+                                          (void *) cid,
+                                          &phone_speaker,
+                                          &phone_mic);
+    }
+    break;
+
+  case GNUNET_CONVERSATION_EC_PHONE_HUNG_UP:
+    if (caller == active_caller2)
+    {
+      active_caller2 = NULL;
+      GNUNET_CONVERSATION_caller_resume (active_caller1,
+                                         &phone_speaker,
+                                         &phone_mic);
+    }
+    else if (caller == active_caller1)
+    {
+      active_caller1 = NULL;
+      GNUNET_break (NULL == active_caller2);
+      GNUNET_SCHEDULER_shutdown ();
+    }
+    break;
+
+  default:
+    LOG (GNUNET_ERROR_TYPE_WARNING, "Unexpected phone code: %d\n", code);
+    break;
+  }
+}
+
+
+static void
+call_event_handler (void *cls, enum GNUNET_CONVERSATION_CallEventCode code)
+{
+  const char *cid = cls;
+
+  switch (code)
+  {
+  case GNUNET_CONVERSATION_EC_CALL_RINGING:
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_PICKED_UP:
+    LOG_DEBUG ("Call %s picked\n", cid);
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_GNS_FAIL:
+    LOG_DEBUG ("Call %s GNS lookup failed \n", cid);
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_HUNG_UP:
+    LOG_DEBUG ("Call %s hungup\n", cid);
+    if (0 == strcmp (cid, "call1"))
+      call1 = NULL;
+    else
+      call2 = NULL;
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_SUSPENDED:
+    LOG_DEBUG ("Call %s suspended\n", cid);
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_RESUMED:
+    LOG_DEBUG ("Call %s resumed\n", cid);
+    break;
+
+  case GNUNET_CONVERSATION_EC_CALL_ERROR:
+    GNUNET_break (0);
+    if (0 == strcmp (cid, "call1"))
+      call1 = NULL;
+    else
+      call2 = NULL;
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+  }
+}
+
+
+static void
+caller_ego_create_cont (void *cls,
+                        const struct GNUNET_CRYPTO_PrivateKey *pk,
+                        enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  op = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+}
+
+
+static void
+namestore_put_cont (void *cls, enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  qe = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+  GNUNET_assert (NULL == op);
+  op = GNUNET_IDENTITY_create (id, "caller-ego", NULL,
+                               GNUNET_PUBLIC_KEY_TYPE_ECDSA,
+                               &caller_ego_create_cont,
+                               NULL);
+}
+
+
+static void
+identity_cb (void *cls,
+             struct GNUNET_IDENTITY_Ego *ego,
+             void **ctx,
+             const char *name)
+{
+  struct GNUNET_GNSRECORD_Data rd;
+  struct GNUNET_CRYPTO_PublicKey pub;
+
+  (void) cls;
+  (void) ctx;
+  if (NULL == name)
+    return;
+  if (NULL == ego)
+    return;
+  if (0 == strcmp (name, "phone-ego"))
+  {
+    GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
+    GNUNET_asprintf (&gns_name,
+                     "phone.%s",
+                     GNUNET_GNSRECORD_pkey_to_zkey (&pub));
+    phone =
+      GNUNET_CONVERSATION_phone_create (cfg, ego, &phone_event_handler, NULL);
+    GNUNET_assert (NULL != phone);
+    memset (&rd, 0, sizeof(rd));
+    GNUNET_CONVERSATION_phone_get_record (phone, &rd);
+    GNUNET_assert (rd.record_type == GNUNET_GNSRECORD_TYPE_PHONE);
+    rd.expiration_time = UINT64_MAX;
+    qe =
+      GNUNET_NAMESTORE_record_set_store (ns,
+                                      GNUNET_IDENTITY_ego_get_private_key (ego),
+                                      "phone" /* GNS label */,
+                                      1,
+                                      &rd,
+                                      &namestore_put_cont,
+                                      NULL);
+    return;
+  }
+  if (0 == strcmp (name, "caller-ego"))
+  {
+    GNUNET_IDENTITY_ego_get_public_key (ego, &pub);
+    GNUNET_asprintf (&gns_caller_id,
+                     "%s",
+                     GNUNET_GNSRECORD_pkey_to_zkey (&pub));
+    call1 = GNUNET_CONVERSATION_call_start (cfg,
+                                            ego,
+                                            gns_name,
+                                            &call1_speaker,
+                                            &call1_mic,
+                                            &call_event_handler,
+                                            (void *) "call1");
+    call2 = GNUNET_CONVERSATION_call_start (cfg,
+                                            ego,
+                                            gns_name,
+                                            &call2_speaker,
+                                            &call2_mic,
+                                            &call_event_handler,
+                                            (void *) "call2");
+    return;
+  }
+}
+
+
+static void
+phone_ego_create_cont (void *cls,
+                       const struct GNUNET_CRYPTO_PrivateKey *pk,
+                       enum GNUNET_ErrorCode ec)
+{
+  (void) cls;
+  op = NULL;
+  GNUNET_assert (GNUNET_EC_NONE == ec);
+}
+
+
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_TESTING_Peer *peer)
+{
+  (void) cls;
+  (void) peer;
+  cfg = c;
+  timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_test, NULL);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+  id = GNUNET_IDENTITY_connect (cfg, &identity_cb, NULL);
+  op = GNUNET_IDENTITY_create (id, "phone-ego", NULL,
+                               GNUNET_PUBLIC_KEY_TYPE_ECDSA,
+                               &phone_ego_create_cont,
+                               NULL);
+  ns = GNUNET_NAMESTORE_connect (cfg);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  (void) argc;
+  (void) argv;
+  if (0 != GNUNET_TESTING_peer_run ("test_conversation_api_twocalls",
+                                    "test_conversation.conf",
+                                    &run,
+                                    NULL))
+    return 1;
+  if (call1_finished && call2_finished)
+    return 0;
+  return 1;
+}
+
+
+/* end of test_conversation_api_twocalls.c */
diff --git a/src/contrib/service/meson.build b/src/contrib/service/meson.build
new file mode 100644
index 000000000..eae7b7c8e
--- /dev/null
+++ b/src/contrib/service/meson.build
@@ -0,0 +1,11 @@
+subdir('template')
+subdir('set')
+subdir('consensus')
+#subdir('auction')
+#subdir('abd')
+#subdir('rps')
+subdir('scalarproduct')
+if conversation_backend != 'none'
+  subdir('conversation')
+endif
+subdir('secretsharing')
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..1a3c9fa3a
--- /dev/null
+++ b/src/contrib/service/rps/Makefile.am
@@ -0,0 +1,149 @@
+# 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/service/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
+
+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/service/peerstore/libgnunetpeerstore.la \
+  $(top_builddir)/src/service/cadet/libgnunetcadet.la \
+  $(top_builddir)/src/service/nse/libgnunetnse.la \
+  $(top_builddir)/src/service/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/service/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)
+
+EXTRA_DIST = \
+  test_rps.conf
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..1ea59104b
--- /dev/null
+++ b/src/contrib/service/rps/gnunet-service-rps.c
@@ -0,0 +1,5028 @@
+/*
+     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_Monitor *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_PEERSTORE_Record *record,
+                        const char *emsg)
+{
+  struct Sub *sub = cls;
+  (void) emsg;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Got peer_id %s from peerinfo\n",
+       GNUNET_i2s (&record->peer));
+  got_peer (sub, &record->peer);
+  GNUNET_PEERSTORE_monitor_next(peerstore_notify, 1);
+}
+
+
+/**
+ * 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_monitor_stop (peerstore_notify);
+  GNUNET_PEERSTORE_disconnect (peerstore);
+  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);
+  }
+}
+
+
+static void
+error_cb (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Error in PEERSTORE monitoring\n");
+}
+
+
+static void
+sync_cb (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Done with initial PEERSTORE iteration during monitoring\n");
+}
+
+
+/**
+ * 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_monitor_start (c,
+                                    GNUNET_YES,
+                                    "peerstore",
+                                    NULL,
+                                    GNUNET_PEERSTORE_HELLO_KEY,
+                                    &error_cb,
+                                    NULL,
+                                    &sync_cb,
+                                    NULL,
+                                    &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..d23a6383d
--- /dev/null
+++ b/src/contrib/service/rps/profiler_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 = 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
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 */
diff --git a/src/contrib/service/scalarproduct/.gitignore b/src/contrib/service/scalarproduct/.gitignore
new file mode 100644
index 000000000..19909a3f9
--- /dev/null
+++ b/src/contrib/service/scalarproduct/.gitignore
@@ -0,0 +1,6 @@
+gnunet-service-scalarproduct-ecc-bob
+gnunet-scalarproduct
+gnunet-service-scalarproduct-alice
+gnunet-service-scalarproduct-bob
+gnunet-service-scalarproduct-ecc-alice
+test_ecc_scalarproduct
diff --git a/src/contrib/service/scalarproduct/Makefile.am b/src/contrib/service/scalarproduct/Makefile.am
new file mode 100644
index 000000000..b12dbace5
--- /dev/null
+++ b/src/contrib/service/scalarproduct/Makefile.am
@@ -0,0 +1,117 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+pkgcfg_DATA = \
+  scalarproduct.conf
+
+if USE_COVERAGE
+  AM_CFLAGS = -fprofile-arcs -ftest-coverage
+endif
+
+bin_PROGRAMS = \
+ gnunet-scalarproduct
+
+libexec_PROGRAMS = \
+ gnunet-service-scalarproduct-alice \
+ gnunet-service-scalarproduct-bob \
+ gnunet-service-scalarproduct-ecc-alice \
+ gnunet-service-scalarproduct-ecc-bob
+
+lib_LTLIBRARIES = \
+  libgnunetscalarproduct.la
+
+gnunet_scalarproduct_SOURCES = \
+  gnunet-scalarproduct.c
+gnunet_scalarproduct_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  libgnunetscalarproduct.la \
+  $(LIBGCRYPT_LIBS) \
+  -lgcrypt \
+  $(GN_LIBINTL)
+
+gnunet_service_scalarproduct_alice_SOURCES = \
+  gnunet-service-scalarproduct.h \
+  gnunet-service-scalarproduct_alice.c
+gnunet_service_scalarproduct_alice_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/service/cadet/libgnunetcadet.la \
+  $(top_builddir)/src/service/seti/libgnunetseti.la \
+  $(LIBGCRYPT_LIBS) \
+  -lgcrypt \
+  $(GN_LIBINTL)
+
+gnunet_service_scalarproduct_bob_SOURCES = \
+  gnunet-service-scalarproduct.h \
+  gnunet-service-scalarproduct_bob.c
+gnunet_service_scalarproduct_bob_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/service/cadet/libgnunetcadet.la \
+  $(top_builddir)/src/service/seti/libgnunetseti.la \
+  $(LIBGCRYPT_LIBS) \
+  -lgcrypt \
+  $(GN_LIBINTL)
+
+gnunet_service_scalarproduct_ecc_alice_SOURCES = \
+  gnunet-service-scalarproduct-ecc.h \
+  gnunet-service-scalarproduct-ecc_alice.c
+gnunet_service_scalarproduct_ecc_alice_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/service/cadet/libgnunetcadet.la \
+  $(top_builddir)/src/service/seti/libgnunetseti.la \
+  $(LIBGCRYPT_LIBS) \
+  -lsodium \
+  -lgcrypt \
+  $(GN_LIBINTL)
+
+gnunet_service_scalarproduct_ecc_bob_SOURCES = \
+  gnunet-service-scalarproduct-ecc.h \
+  gnunet-service-scalarproduct-ecc_bob.c
+gnunet_service_scalarproduct_ecc_bob_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/service/cadet/libgnunetcadet.la \
+  $(top_builddir)/src/service/seti/libgnunetseti.la \
+  $(LIBGCRYPT_LIBS) \
+  -lsodium \
+  -lgcrypt \
+  $(GN_LIBINTL)
+
+libgnunetscalarproduct_la_SOURCES = \
+  scalarproduct_api.c \
+  scalarproduct.h
+libgnunetscalarproduct_la_LIBADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(LIBGCRYPT_LIBS) \
+  -lgcrypt \
+  $(LTLIBINTL)
+libgnunetscalarproduct_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)
+
+EXTRA_DIST = \
+  test_scalarproduct.conf \
+  $(check_SCRIPTS)
+
+# Need deprecated and removed testbed profiler
+#check_SCRIPTS = \
+#  test_scalarproduct.sh \
+#  test_scalarproduct_negative.sh \
+#  test_scalarproduct_negativezero.sh
+
+check_PROGRAMS = \
+  # test_ecc_scalarproduct
+
+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_SCRIPTS) $(check_PROGRAMS)
+endif
+
+
+test_ecc_scalarproduct_SOURCES = \
+ test_ecc_scalarproduct.c
+test_ecc_scalarproduct_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  -lsodium
diff --git a/src/contrib/service/scalarproduct/gnunet-scalarproduct.c b/src/contrib/service/scalarproduct/gnunet-scalarproduct.c
new file mode 100644
index 000000000..5ebab5baf
--- /dev/null
+++ b/src/contrib/service/scalarproduct/gnunet-scalarproduct.c
@@ -0,0 +1,401 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013, 2014 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 scalarproduct/gnunet-scalarproduct.c
+ * @brief scalarproduct client
+ * @author Christian M. Fuchs
+ */
+#define GCRYPT_NO_DEPRECATED
+#include "platform.h"
+#include <gcrypt.h>
+#include <inttypes.h>
+
+#include "gnunet_util_lib.h"
+#include "gnunet_scalarproduct_service.h"
+#include "gnunet_protocols.h"
+#include "scalarproduct.h"
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "gnunet-scalarproduct", \
+                                        __VA_ARGS__)
+
+
+/**
+ * the session key identifying this computation
+ */
+static struct GNUNET_HashCode session_key;
+
+/**
+ * PeerID we want to compute a scalar product with
+ */
+static struct GNUNET_PeerIdentity peer_id;
+
+/**
+ * Option -p: destination peer identity for checking message-ids with
+ */
+static char *input_peer_id;
+
+/**
+ * Option -p: destination peer identity for checking message-ids with
+ */
+static char *input_session_key;
+
+/**
+ * Option -e: vector to calculate a scalarproduct with
+ */
+static char *input_elements;
+
+/**
+ * Global return value
+ */
+static int ret = -1;
+
+/**
+ * our Scalarproduct Computation handle
+ */
+static struct GNUNET_SCALARPRODUCT_ComputationHandle *computation;
+
+
+/**
+ * Callback called if we are initiating a new computation session
+ *
+ * @param cls unused
+ * @param status if our job was successfully processed
+ */
+static void
+responder_callback (void *cls,
+                    enum GNUNET_SCALARPRODUCT_ResponseStatus status)
+{
+  switch (status)
+  {
+  case GNUNET_SCALARPRODUCT_STATUS_SUCCESS:
+    ret = 0;
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "Session %s concluded.\n",
+         GNUNET_h2s (&session_key));
+    break;
+
+  case GNUNET_SCALARPRODUCT_STATUS_INVALID_RESPONSE:
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Session %s failed: invalid response\n",
+         GNUNET_h2s (&session_key));
+    break;
+
+  case GNUNET_SCALARPRODUCT_STATUS_FAILURE:
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Session %s failed: service failure\n",
+         GNUNET_h2s (&session_key));
+    break;
+
+  case GNUNET_SCALARPRODUCT_STATUS_DISCONNECTED:
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Session %s failed: service disconnect!\n",
+         GNUNET_h2s (&session_key));
+    break;
+
+  default:
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Session %s failed: return code %d\n",
+         GNUNET_h2s (&session_key),
+         status);
+  }
+  computation = NULL;
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * Callback called if we are initiating a new computation session
+ *
+ * @param cls unused
+ * @param status if our job was successfully processed
+ * @param result the result in gnu/gcry MPI format
+ */
+static void
+requester_callback (void *cls,
+                    enum GNUNET_SCALARPRODUCT_ResponseStatus status,
+                    gcry_mpi_t result)
+{
+  unsigned char *buf;
+  gcry_error_t rc;
+
+  switch (status)
+  {
+  case GNUNET_SCALARPRODUCT_STATUS_SUCCESS:
+    if (0 == (rc = gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buf, NULL, result)))
+    {
+      ret = 0;
+      fprintf (stdout,
+               "%s\n",
+               buf);
+      fflush (stdout);
+    }
+    else
+      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR,
+                "gcry_mpi_aprint",
+                rc);
+    break;
+
+  case GNUNET_SCALARPRODUCT_STATUS_INVALID_RESPONSE:
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Session %s with peer %s failed: invalid response received\n",
+         GNUNET_h2s (&session_key),
+         GNUNET_i2s (&peer_id));
+    break;
+
+  case GNUNET_SCALARPRODUCT_STATUS_FAILURE:
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Session %s with peer %s failed: API failure\n",
+         GNUNET_h2s (&session_key),
+         GNUNET_i2s (&peer_id));
+    break;
+
+  case GNUNET_SCALARPRODUCT_STATUS_DISCONNECTED:
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Session %s with peer %s was disconnected from service.\n",
+         GNUNET_h2s (&session_key),
+         GNUNET_i2s (&peer_id));
+    break;
+
+  default:
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Session %s with peer %s failed: return code %d\n",
+         GNUNET_h2s (&session_key),
+         GNUNET_i2s (&peer_id),
+         status);
+  }
+  computation = NULL;
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * Task run during shutdown.
+ *
+ * @param cls unused
+ */
+static void
+shutdown_task (void *cls)
+{
+  if (NULL != computation)
+  {
+    GNUNET_SCALARPRODUCT_cancel (computation);
+    ret = 1;   /* aborted */
+  }
+}
+
+
+/**
+ * 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)
+{
+  char *begin = input_elements;
+  char *end;
+  unsigned int i;
+  struct GNUNET_SCALARPRODUCT_Element *elements;
+  uint32_t element_count = 0;
+
+  if (NULL == input_elements)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         _ ("You must specify at least one message ID to check!\n"));
+    return;
+  }
+  if ((NULL == input_session_key) ||
+      (0 == strlen (input_session_key)))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         _ (
+           "This program needs a session identifier for comparing vectors.\n"));
+    return;
+  }
+  GNUNET_CRYPTO_hash (input_session_key,
+                      strlen (input_session_key),
+                      &session_key);
+  if ((NULL != input_peer_id) &&
+      (GNUNET_OK !=
+       GNUNET_CRYPTO_eddsa_public_key_from_string (input_peer_id,
+                                                   strlen (input_peer_id),
+                                                   &peer_id.public_key)))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         _ ("Tried to set initiator mode, as peer ID was given. "
+            "However, `%s' is not a valid peer identifier.\n"),
+         input_peer_id);
+    return;
+  }
+  if (('\'' == *begin) &&
+      ('\'' == begin[strlen (begin) - 1]))
+  {
+    begin[strlen (begin) - 1] = '\0';
+    if (strlen (begin) > 0)
+      begin++;
+  }
+  for (end = begin; 0 != *end; end++)
+    if (*end == ';')
+      element_count++;
+  if (0 == element_count)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         _ ("Need elements to compute the scalarproduct, got none.\n"));
+    return;
+  }
+
+  elements = GNUNET_malloc (sizeof(struct GNUNET_SCALARPRODUCT_Element)
+                            * element_count);
+
+  for (i = 0; i < element_count; i++)
+  {
+    struct GNUNET_SCALARPRODUCT_Element element;
+    char*separator = NULL;
+
+    /* get the length of the current key,value; tuple */
+    for (end = begin; *end != ';'; end++)
+      if (*end == ',')
+        separator = end;
+
+    /* final element */
+    if ((NULL == separator) ||
+        (begin == separator) ||
+        (separator == end - 1))
+    {
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           _ ("Malformed input, could not parse `%s'\n"),
+           begin);
+      GNUNET_free (elements);
+      return;
+    }
+    *separator = 0;
+    /* read the element's key */
+    GNUNET_CRYPTO_hash (begin,
+                        strlen (begin),
+                        &element.key);
+
+    /* read the element's value */
+    if (1 !=
+        sscanf (separator + 1,
+                "%" SCNd64 ";",
+                &element.value))
+    {
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           _ ("Could not convert `%s' to int64_t.\n"),
+           begin);
+      GNUNET_free (elements);
+      return;
+    }
+    element.value = GNUNET_htonll (element.value);
+    elements[i] = element;
+    begin = end + 1;
+  }
+
+  if (((NULL != input_peer_id) &&
+       (NULL == (computation
+                   = GNUNET_SCALARPRODUCT_start_computation (cfg,
+                                                             &session_key,
+                                                             &peer_id,
+                                                             elements,
+                                                             element_count,
+                                                             &requester_callback,
+                                                             NULL)))) ||
+      ((NULL == input_peer_id) &&
+       (NULL == (computation
+                   = GNUNET_SCALARPRODUCT_accept_computation (cfg,
+                                                              &session_key,
+                                                              elements,
+                                                              element_count,
+                                                              &
+                                                              responder_callback,
+                                                              NULL)))))
+  {
+    fprintf (stderr,
+             _ ("Failed to initiate computation, were all keys unique?\n"));
+    GNUNET_free (elements);
+    return;
+  }
+  GNUNET_free (elements);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
+                                 NULL);
+  ret = 0;
+}
+
+
+/**
+ * The main function to the scalarproduct client.
+ *
+ * @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_string ('e',
+                                 "elements",
+                                 "\"key1,val1;key2,val2;...,keyn,valn;\"",
+                                 gettext_noop (
+                                   "A comma separated list of elements to compare as vector with our remote peer."),
+                                 &input_elements),
+
+    GNUNET_GETOPT_option_string ('e',
+                                 "elements",
+                                 "\"key1,val1;key2,val2;...,keyn,valn;\"",
+                                 gettext_noop (
+                                   "A comma separated list of elements to compare as vector with our remote peer."),
+                                 &input_elements),
+
+    GNUNET_GETOPT_option_string ('p',
+                                 "peer",
+                                 "PEERID",
+                                 gettext_noop (
+                                   "[Optional] peer to calculate our scalarproduct with. If this parameter is not given, the service will wait for a remote peer to compute the request."),
+                                 &input_peer_id),
+
+    GNUNET_GETOPT_option_string ('k',
+                                 "key",
+                                 "TRANSACTION_ID",
+                                 gettext_noop (
+                                   "Transaction ID shared with peer."),
+                                 &input_session_key),
+
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  return (GNUNET_OK ==
+          GNUNET_PROGRAM_run (argc,
+                              argv,
+                              "gnunet-scalarproduct",
+                              gettext_noop (
+                                "Calculate the Vectorproduct with a GNUnet peer."),
+                              options, &run, NULL)) ? ret : 1;
+}
+
+
+/* end of gnunet-scalarproduct.c */
diff --git a/src/contrib/service/scalarproduct/gnunet-service-scalarproduct-ecc.h b/src/contrib/service/scalarproduct/gnunet-service-scalarproduct-ecc.h
new file mode 100644
index 000000000..5c7a8d8f1
--- /dev/null
+++ b/src/contrib/service/scalarproduct/gnunet-service-scalarproduct-ecc.h
@@ -0,0 +1,118 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2015 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file scalarproduct/gnunet-service-scalarproduct-ecc.h
+ * @brief scalarproduct service  P2P messages
+ * @author Christian M. Fuchs
+ * @author Christian Grothoff
+ */
+#ifndef GNUNET_SERVICE_SCALARPRODUCT_ECC_H
+#define GNUNET_SERVICE_SCALARPRODUCT_ECC_H
+
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * Message type passed from requesting service Alice to responding
+ * service Bob to initiate a request and make Bob participate in our
+ * protocol.  Afterwards, Bob is expected to perform the set
+ * intersection with Alice. Once that has succeeded, Alice will
+ * send a `struct AliceCryptodataMessage *`.  Bob is not expected
+ * to respond via CADET in the meantime.
+ */
+struct EccServiceRequestMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * For alignment. Always zero.
+   */
+  uint32_t reserved;
+
+  /**
+   * The transaction/session key used to identify a session
+   */
+  struct GNUNET_HashCode session_id;
+};
+
+
+/**
+ * Vector of ECC-encrypted values sent by Alice to Bob
+ * (after set intersection).  Alice may send messages of this
+ * type repeatedly to transmit all values.
+ */
+struct EccAliceCryptodataMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * How many elements we appended to this message? In NBO.
+   */
+  uint32_t contained_element_count GNUNET_PACKED;
+
+  /**
+   * struct GNUNET_CRYPTO_EccPoint[contained_element_count]
+   */
+};
+
+
+/**
+ * Message type passed from responding service Bob to responding
+ * service Alice to complete a request and allow Alice to compute the
+ * result.  If Bob's reply does not fit into this one message, the
+ * conversation may be continued with `struct BobCryptodataMultipartMessage`
+ * messages afterwards.
+ */
+struct EccBobCryptodataMessage
+{
+  /**
+   * GNUNET message header with type
+   * #GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * How many elements this individual message delivers (in NBO),
+   * always TWO.
+   */
+  uint32_t contained_element_count GNUNET_PACKED;
+
+  /**
+   * The product of the g_i^{b_i} values.
+   */
+  struct GNUNET_CRYPTO_EccPoint prod_g_i_b_i;
+
+  /**
+   * The product of the h_i^{b_i} values.
+   */
+  struct GNUNET_CRYPTO_EccPoint prod_h_i_b_i;
+};
+
+
+GNUNET_NETWORK_STRUCT_END
+
+
+#endif
diff --git a/src/contrib/service/scalarproduct/gnunet-service-scalarproduct-ecc_alice.c b/src/contrib/service/scalarproduct/gnunet-service-scalarproduct-ecc_alice.c
new file mode 100644
index 000000000..b8bac0803
--- /dev/null
+++ b/src/contrib/service/scalarproduct/gnunet-service-scalarproduct-ecc_alice.c
@@ -0,0 +1,1150 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013-2017, 2021 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file scalarproduct/gnunet-service-scalarproduct-ecc_alice.c
+ * @brief scalarproduct service implementation
+ * @author Christian M. Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include <limits.h>
+#include <gcrypt.h>
+#include "gnunet_util_lib.h"
+#include "gnunet_core_service.h"
+#include "gnunet_cadet_service.h"
+#include "gnunet_applications.h"
+#include "gnunet_protocols.h"
+#include "gnunet_scalarproduct_service.h"
+#include "gnunet_seti_service.h"
+#include "scalarproduct.h"
+#include "gnunet-service-scalarproduct-ecc.h"
+#include "gnunet_constants.h"
+
+#define LOG(kind, ...) \
+  GNUNET_log_from (kind, "scalarproduct-alice", __VA_ARGS__)
+
+/**
+ * Maximum allowed result value for the scalarproduct computation.
+ * DLOG will fail if the result is bigger.  At 1 million, the
+ * precomputation takes about 2s on a fast machine.
+ */
+#define MAX_RESULT (1024 * 1024)
+
+/**
+ * How many values should DLOG store in memory (determines baseline
+ * RAM consumption, roughly 100 bytes times the value given here).
+ * Should be about SQRT (MAX_RESULT), larger values will make the
+ * online computation faster.
+ */
+#define MAX_RAM (1024)
+
+/**
+ * An encrypted element key-value pair.
+ */
+struct MpiElement
+{
+  /**
+   * Key used to identify matching pairs of values to multiply.
+   * Points into an existing data structure, to avoid copying
+   * and doubling memory use.
+   */
+  const struct GNUNET_HashCode *key;
+
+  /**
+   * a_i value, not disclosed to Bob.
+   */
+  int64_t value;
+};
+
+
+/**
+ * A scalarproduct session which tracks
+ * a request form the client to our final response.
+ */
+struct AliceServiceSession
+{
+  /**
+   * (hopefully) unique transaction ID
+   */
+  struct GNUNET_HashCode session_id;
+
+  /**
+   * Alice or Bob's peerID
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /**
+   * The client this request is related to.
+   */
+  struct GNUNET_SERVICE_Client *client;
+
+  /**
+   * The message queue for the client.
+   */
+  struct GNUNET_MQ_Handle *client_mq;
+
+  /**
+   * The message queue for CADET.
+   */
+  struct GNUNET_MQ_Handle *cadet_mq;
+
+  /**
+   * all non-0-value'd elements transmitted to us.
+   * Values are of type `struct GNUNET_SCALARPRODUCT_Element *`
+   */
+  struct GNUNET_CONTAINER_MultiHashMap *intersected_elements;
+
+  /**
+   * Set of elements for which will conduction an intersection.
+   * the resulting elements are then used for computing the scalar product.
+   */
+  struct GNUNET_SETI_Handle *intersection_set;
+
+  /**
+   * Set of elements for which will conduction an intersection.
+   * the resulting elements are then used for computing the scalar product.
+   */
+  struct GNUNET_SETI_OperationHandle *intersection_op;
+
+  /**
+   * Handle to Alice's Intersection operation listening for Bob
+   */
+  struct GNUNET_SETI_ListenHandle *intersection_listen;
+
+  /**
+   * channel-handle associated with our cadet handle
+   */
+  struct GNUNET_CADET_Channel *channel;
+
+  /**
+   * a(Alice), sorted array by key of length @e used_element_count.
+   */
+  struct MpiElement *sorted_elements;
+
+  /**
+   * The computed scalar product. INT_MAX if the computation failed.
+   */
+  int product;
+
+  /**
+   * How many elements we were supplied with from the client (total
+   * count before intersection).
+   */
+  uint32_t total;
+
+  /**
+   * How many elements actually are used for the scalar product.
+   * Size of the arrays in @e r and @e r_prime.  Sometimes also
+   * reset to 0 and used as a counter!
+   */
+  uint32_t used_element_count;
+
+  /**
+   * Already transferred elements from client to us.
+   * Less or equal than @e total.
+   */
+  uint32_t client_received_element_count;
+
+  /**
+   * State of this session.   In
+   * #GNUNET_SCALARPRODUCT_STATUS_ACTIVE while operation is
+   * ongoing, afterwards in #GNUNET_SCALARPRODUCT_STATUS_SUCCESS or
+   * #GNUNET_SCALARPRODUCT_STATUS_FAILURE.
+   */
+  enum GNUNET_SCALARPRODUCT_ResponseStatus status;
+
+  /**
+   * Flag to prevent recursive calls to #destroy_service_session() from
+   * doing harm.
+   */
+  int in_destroy;
+};
+
+
+/**
+ * GNUnet configuration handle
+ */
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Context for DLOG operations on a curve.
+ */
+static struct GNUNET_CRYPTO_EccDlogContext *edc;
+
+/**
+ * Alice's private key ('a').
+ */
+static struct GNUNET_CRYPTO_EccScalar my_privkey;
+
+/**
+ * Inverse of Alice's private key ('a_inv').
+ */
+static struct GNUNET_CRYPTO_EccScalar my_privkey_inv;
+
+/**
+ * Handle to the CADET service.
+ */
+static struct GNUNET_CADET_Handle *my_cadet;
+
+
+/**
+ * Iterator called to free elements.
+ *
+ * @param cls the `struct AliceServiceSession *` (unused)
+ * @param key the key (unused)
+ * @param value value to free
+ * @return #GNUNET_OK (continue to iterate)
+ */
+static int
+free_element_cb (void *cls,
+                 const struct GNUNET_HashCode *key,
+                 void *value)
+{
+  struct GNUNET_SCALARPRODUCT_Element *e = value;
+
+  GNUNET_free (e);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Destroy session state, we are done with it.
+ *
+ * @param s the session to free elements from
+ */
+static void
+destroy_service_session (struct AliceServiceSession *s)
+{
+  if (GNUNET_YES == s->in_destroy)
+    return;
+  s->in_destroy = GNUNET_YES;
+  if (NULL != s->client)
+  {
+    struct GNUNET_SERVICE_Client *c = s->client;
+
+    s->client = NULL;
+    GNUNET_SERVICE_client_drop (c);
+  }
+  if (NULL != s->channel)
+  {
+    GNUNET_CADET_channel_destroy (s->channel);
+    s->channel = NULL;
+  }
+  if (NULL != s->intersected_elements)
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (s->intersected_elements,
+                                           &free_element_cb,
+                                           s);
+    GNUNET_CONTAINER_multihashmap_destroy (s->intersected_elements);
+    s->intersected_elements = NULL;
+  }
+  if (NULL != s->intersection_listen)
+  {
+    GNUNET_SETI_listen_cancel (s->intersection_listen);
+    s->intersection_listen = NULL;
+  }
+  if (NULL != s->intersection_op)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Set intersection, op still ongoing!\n");
+    GNUNET_SETI_operation_cancel (s->intersection_op);
+    s->intersection_op = NULL;
+  }
+  if (NULL != s->intersection_set)
+  {
+    GNUNET_SETI_destroy (s->intersection_set);
+    s->intersection_set = NULL;
+  }
+  if (NULL != s->sorted_elements)
+  {
+    GNUNET_free (s->sorted_elements);
+    s->sorted_elements = NULL;
+  }
+  GNUNET_free (s);
+}
+
+
+/**
+ * Notify the client that the session has failed.  A message gets sent
+ * to Alice's client if we encountered any error.
+ *
+ * @param session the associated client session to fail or succeed
+ */
+static void
+prepare_client_end_notification (struct AliceServiceSession *session)
+{
+  struct ClientResponseMessage *msg;
+  struct GNUNET_MQ_Envelope *e;
+
+  if (NULL == session->client_mq)
+    return; /* no client left to be notified */
+  GNUNET_log (
+    GNUNET_ERROR_TYPE_DEBUG,
+    "Sending session-end notification with status %d to client for session %s\n",
+    session->status,
+    GNUNET_h2s (&session->session_id));
+  e = GNUNET_MQ_msg (msg,
+                     GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT);
+  msg->product_length = htonl (0);
+  msg->status = htonl (session->status);
+  GNUNET_MQ_send (session->client_mq,
+                  e);
+}
+
+
+/**
+ * Prepare the final (positive) response we will send to Alice's
+ * client.
+ *
+ * @param s the session associated with our client.
+ */
+static void
+transmit_client_response (struct AliceServiceSession *s)
+{
+  struct ClientResponseMessage *msg;
+  struct GNUNET_MQ_Envelope *e;
+  unsigned char *product_exported = NULL;
+  size_t product_length = 0;
+  int32_t range;
+  gcry_error_t rc;
+  gcry_mpi_t value;
+
+  if (INT_MAX == s->product)
+  {
+    GNUNET_break (0);
+    prepare_client_end_notification (s);
+    return;
+  }
+  value = gcry_mpi_new (32);
+  if (0 > s->product)
+  {
+    range = -1;
+    gcry_mpi_set_ui (value,
+                     -s->product);
+  }
+  else if (0 < s->product)
+  {
+    range = 1;
+    gcry_mpi_set_ui (value,
+                     s->product);
+  }
+  else
+  {
+    /* result is exactly zero */
+    range = 0;
+  }
+  if ( (0 != range) &&
+       (0 != (rc = gcry_mpi_aprint (GCRYMPI_FMT_STD,
+                                    &product_exported,
+                                    &product_length,
+                                    value))))
+  {
+    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR,
+              "gcry_mpi_scan",
+              rc);
+    prepare_client_end_notification (s);
+    return;
+  }
+  gcry_mpi_release (value);
+  e = GNUNET_MQ_msg_extra (msg,
+                           product_length,
+                           GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT);
+  msg->status = htonl (GNUNET_SCALARPRODUCT_STATUS_SUCCESS);
+  msg->range = htonl (range);
+  msg->product_length = htonl (product_length);
+  if (NULL != product_exported)
+  {
+    GNUNET_memcpy (&msg[1],
+                   product_exported,
+                   product_length);
+    GNUNET_free (product_exported);
+  }
+  GNUNET_MQ_send (s->client_mq,
+                  e);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sent result to client, session %s has ended!\n",
+              GNUNET_h2s (&s->session_id));
+}
+
+
+/**
+ * Function called whenever a channel is destroyed.  Should clean up
+ * any associated state.
+ *
+ * It must NOT call #GNUNET_CADET_channel_destroy() on the channel.
+ *
+ * @param cls the `struct AliceServiceSession`
+ * @param channel connection to the other end (henceforth invalid)
+ */
+static void
+cb_channel_destruction (void *cls,
+                        const struct GNUNET_CADET_Channel *channel)
+{
+  struct AliceServiceSession *s = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Peer disconnected, terminating session %s with peer %s\n",
+              GNUNET_h2s (&s->session_id),
+              GNUNET_i2s (&s->peer));
+  s->channel = NULL;
+  if (GNUNET_SCALARPRODUCT_STATUS_ACTIVE == s->status)
+  {
+    /* We didn't get an answer yet, fail with error */
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    prepare_client_end_notification (s);
+  }
+}
+
+
+/**
+ * Handle a response we got from another service we wanted to
+ * calculate a scalarproduct with.
+ *
+ * @param cls the `struct AliceServiceSession *`
+ * @param msg the actual message
+ */
+static void
+handle_bobs_cryptodata_message (void *cls,
+                                const struct EccBobCryptodataMessage *msg)
+{
+  struct AliceServiceSession *s = cls;
+  uint32_t contained;
+
+  contained = ntohl (msg->contained_element_count);
+  if (2 != contained)
+  {
+    GNUNET_break_op (0);
+    destroy_service_session (s);
+    return;
+  }
+  if (NULL == s->sorted_elements)
+  {
+    /* we're not ready yet, how can Bob be? */
+    GNUNET_break_op (0);
+    destroy_service_session (s);
+    return;
+  }
+  if (s->total != s->client_received_element_count)
+  {
+    /* we're not ready yet, how can Bob be? */
+    GNUNET_break_op (0);
+    destroy_service_session (s);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received %u crypto values from Bob\n",
+              (unsigned int) contained);
+  GNUNET_CADET_receive_done (s->channel);
+  {
+    struct GNUNET_CRYPTO_EccPoint g_i_b_i_a_inv;
+    struct GNUNET_CRYPTO_EccPoint g_ai_bi;
+
+    GNUNET_assert (
+      GNUNET_OK ==
+      GNUNET_CRYPTO_ecc_pmul_mpi (&msg->prod_g_i_b_i,
+                                  &my_privkey_inv,
+                                  &g_i_b_i_a_inv));
+    GNUNET_assert (
+      GNUNET_OK ==
+      GNUNET_CRYPTO_ecc_add (&g_i_b_i_a_inv,
+                             &msg->prod_h_i_b_i,
+                             &g_ai_bi));
+    s->product = GNUNET_CRYPTO_ecc_dlog (edc,
+                                         &g_ai_bi);
+    if (INT_MAX == s->product)
+    {
+      /* result too big */
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Scalar product result out of range\n");
+    }
+  }
+  transmit_client_response (s);
+}
+
+
+/**
+ * Iterator to copy over messages from the hash map
+ * into an array for sorting.
+ *
+ * @param cls the `struct AliceServiceSession *`
+ * @param key the key (unused)
+ * @param value the `struct GNUNET_SCALARPRODUCT_Element *`
+ */
+static int
+copy_element_cb (void *cls,
+                 const struct GNUNET_HashCode *key,
+                 void *value)
+{
+  struct AliceServiceSession *s = cls;
+  struct GNUNET_SCALARPRODUCT_Element *e = value;
+
+  s->sorted_elements[s->used_element_count].value = (int64_t) GNUNET_ntohll (
+    e->value);
+  s->sorted_elements[s->used_element_count].key = &e->key;
+  s->used_element_count++;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Compare two `struct MpiValue`s by key for sorting.
+ *
+ * @param a pointer to first `struct MpiValue *`
+ * @param b pointer to first `struct MpiValue *`
+ * @return -1 for a < b, 0 for a=b, 1 for a > b.
+ */
+static int
+element_cmp (const void *a,
+             const void *b)
+{
+  const struct MpiElement *ma = a;
+  const struct MpiElement *mb = b;
+
+  return GNUNET_CRYPTO_hash_cmp (ma->key,
+                                 mb->key);
+}
+
+
+/**
+ * Maximum number of elements we can put into a single cryptodata
+ * message
+ */
+#define ELEMENT_CAPACITY                          \
+  ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1   \
+    - sizeof(struct EccAliceCryptodataMessage))    \
+   / sizeof(struct GNUNET_CRYPTO_EccPoint))
+
+
+/**
+ * Send the cryptographic data from Alice to Bob.
+ * Does nothing if we already transferred all elements.
+ *
+ * @param s the associated service session
+ */
+static void
+send_alices_cryptodata_message (struct AliceServiceSession *s)
+{
+  struct EccAliceCryptodataMessage *msg;
+  struct GNUNET_MQ_Envelope *e;
+  struct GNUNET_CRYPTO_EccPoint *payload;
+  struct GNUNET_CRYPTO_EccScalar r_ia;
+  struct GNUNET_CRYPTO_EccScalar r_ia_ai;
+  unsigned int off;
+  unsigned int todo_count;
+
+  s->sorted_elements = GNUNET_new_array (GNUNET_CONTAINER_multihashmap_size (
+                                           s->intersected_elements),
+                                         struct MpiElement);
+  s->used_element_count = 0;
+  GNUNET_CONTAINER_multihashmap_iterate (s->intersected_elements,
+                                         &copy_element_cb,
+                                         s);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Finished intersection, %d items remain\n",
+       s->used_element_count);
+  qsort (s->sorted_elements,
+         s->used_element_count,
+         sizeof(struct MpiElement),
+         &element_cmp);
+  off = 0;
+  while (off < s->used_element_count)
+  {
+    todo_count = s->used_element_count - off;
+    if (todo_count > ELEMENT_CAPACITY)
+      todo_count = ELEMENT_CAPACITY;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending %u/%u crypto values to Bob\n",
+                (unsigned int) todo_count,
+                (unsigned int) s->used_element_count);
+
+    e =
+      GNUNET_MQ_msg_extra (msg,
+                           todo_count * 2
+                           * sizeof(struct GNUNET_CRYPTO_EccPoint),
+                           GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA);
+    msg->contained_element_count = htonl (todo_count);
+    payload = (struct GNUNET_CRYPTO_EccPoint *) &msg[1];
+    for (unsigned int i = off; i < off + todo_count; i++)
+    {
+      struct GNUNET_CRYPTO_EccScalar r_i;
+      struct GNUNET_CRYPTO_EccPoint g_i;
+      struct GNUNET_CRYPTO_EccPoint h_i;
+
+      /* r_i = random() mod n */
+      GNUNET_CRYPTO_ecc_random_mod_n (&r_i);
+      /* g_i = g^{r_i} */
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CRYPTO_ecc_dexp_mpi (&r_i,
+                                                 &g_i));
+      /* r_ia = r_i * a */
+      crypto_core_ed25519_scalar_mul (r_ia.v,
+                                      r_i.v,
+                                      my_privkey.v);
+      /* r_ia_ai = r_ia + a_i */
+      {
+        int64_t val = s->sorted_elements[i].value;
+        struct GNUNET_CRYPTO_EccScalar vali;
+
+        GNUNET_assert (INT64_MIN != val);
+        GNUNET_CRYPTO_ecc_scalar_from_int (val > 0 ? val : -val,
+                                           &vali);
+        if (val > 0)
+          crypto_core_ed25519_scalar_add (r_ia_ai.v,
+                                          r_ia.v,
+                                          vali.v);
+        else
+          crypto_core_ed25519_scalar_sub (r_ia_ai.v,
+                                          r_ia.v,
+                                          vali.v);
+      }
+      /* h_i = g^{r_ia_ai} */
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CRYPTO_ecc_dexp_mpi (&r_ia_ai,
+                                                 &h_i));
+      memcpy (&payload[(i - off) * 2],
+              &g_i,
+              sizeof (g_i));
+      memcpy (&payload[(i - off) * 2 + 1],
+              &h_i,
+              sizeof (h_i));
+    }
+    off += todo_count;
+    GNUNET_MQ_send (s->cadet_mq,
+                    e);
+  }
+}
+
+
+/**
+ * Callback for set operation results. Called for each element
+ * that should be removed from the result set, and then once
+ * to indicate that the set intersection operation is done.
+ *
+ * @param cls closure with the `struct AliceServiceSession`
+ * @param element a result element, only valid if status is #GNUNET_SETI_STATUS_OK
+ * @param current_size current set size
+ * @param status what has happened with the set intersection?
+ */
+static void
+cb_intersection_element_removed (void *cls,
+                                 const struct GNUNET_SETI_Element *element,
+                                 uint64_t current_size,
+                                 enum GNUNET_SETI_Status status)
+{
+  struct AliceServiceSession *s = cls;
+  struct GNUNET_SCALARPRODUCT_Element *se;
+
+  switch (status)
+  {
+  case GNUNET_SETI_STATUS_DEL_LOCAL:
+    /* this element has been removed from the set */
+    se = GNUNET_CONTAINER_multihashmap_get (s->intersected_elements,
+                                            element->data);
+    GNUNET_assert (NULL != se);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Intersection removed element with key %s and value %lld\n",
+         GNUNET_h2s (&se->key),
+         (long long) GNUNET_ntohll (se->value));
+    GNUNET_assert (
+      GNUNET_YES ==
+      GNUNET_CONTAINER_multihashmap_remove (s->intersected_elements,
+                                            element->data,
+                                            se));
+    GNUNET_free (se);
+    return;
+  case GNUNET_SETI_STATUS_DONE:
+    s->intersection_op = NULL;
+    if (NULL != s->intersection_set)
+    {
+      GNUNET_SETI_destroy (s->intersection_set);
+      s->intersection_set = NULL;
+    }
+    send_alices_cryptodata_message (s);
+    return;
+  case GNUNET_SETI_STATUS_FAILURE:
+    /* unhandled status code */
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Set intersection failed!\n");
+    if (NULL != s->intersection_listen)
+    {
+      GNUNET_SETI_listen_cancel (s->intersection_listen);
+      s->intersection_listen = NULL;
+    }
+    s->intersection_op = NULL;
+    if (NULL != s->intersection_set)
+    {
+      GNUNET_SETI_destroy (s->intersection_set);
+      s->intersection_set = NULL;
+    }
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    prepare_client_end_notification (s);
+    return;
+
+  default:
+    GNUNET_break (0);
+    return;
+  }
+}
+
+
+/**
+ * Called when another peer wants to do a set operation with the
+ * local peer. If a listen error occurs, the @a request is NULL.
+ *
+ * @param cls closure with the `struct AliceServiceSession *`
+ * @param other_peer the other peer
+ * @param context_msg message with application specific information from
+ *        the other peer
+ * @param request request from the other peer (never NULL), use GNUNET_SETI_accept()
+ *        to accept it, otherwise the request will be refused
+ *        Note that we can't just return value from the listen callback,
+ *        as it is also necessary to specify the set we want to do the
+ *        operation with, which sometimes can be derived from the context
+ *        message. It's necessary to specify the timeout.
+ */
+static void
+cb_intersection_request_alice (void *cls,
+                               const struct GNUNET_PeerIdentity *other_peer,
+                               const struct GNUNET_MessageHeader *context_msg,
+                               struct GNUNET_SETI_Request *request)
+{
+  struct AliceServiceSession *s = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received intersection request from %s!\n",
+              GNUNET_i2s (other_peer));
+  if (0 != GNUNET_memcmp (other_peer,
+                          &s->peer))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  s->intersection_op
+    = GNUNET_SETI_accept (request,
+                          (struct GNUNET_SETI_Option[]){ { 0 } },
+                          &cb_intersection_element_removed,
+                          s);
+  if (NULL == s->intersection_op)
+  {
+    GNUNET_break (0);
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    prepare_client_end_notification (s);
+    return;
+  }
+  if (GNUNET_OK !=
+      GNUNET_SETI_commit (s->intersection_op,
+                          s->intersection_set))
+  {
+    GNUNET_break (0);
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    prepare_client_end_notification (s);
+    return;
+  }
+}
+
+
+/**
+ * Our client has finished sending us its multipart message.
+ *
+ * @param s the service session context
+ */
+static void
+client_request_complete_alice (struct AliceServiceSession *s)
+{
+  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
+    GNUNET_MQ_hd_fixed_size (bobs_cryptodata_message,
+                             GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA,
+                             struct EccBobCryptodataMessage,
+                             s),
+    GNUNET_MQ_handler_end ()
+  };
+  struct EccServiceRequestMessage *msg;
+  struct GNUNET_MQ_Envelope *e;
+  struct GNUNET_HashCode set_sid;
+
+  GNUNET_CRYPTO_hash (&s->session_id,
+                      sizeof(struct GNUNET_HashCode),
+                      &set_sid);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Creating new channel for session with key %s.\n",
+              GNUNET_h2s (&s->session_id));
+  s->channel = GNUNET_CADET_channel_create (my_cadet,
+                                            s,
+                                            &s->peer,
+                                            &s->session_id,
+                                            NULL,
+                                            &cb_channel_destruction,
+                                            cadet_handlers);
+  if (NULL == s->channel)
+  {
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    prepare_client_end_notification (s);
+    return;
+  }
+  s->cadet_mq = GNUNET_CADET_get_mq (s->channel);
+  s->intersection_listen = GNUNET_SETI_listen (cfg,
+                                               &set_sid,
+                                               &cb_intersection_request_alice,
+                                               s);
+  if (NULL == s->intersection_listen)
+  {
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    GNUNET_CADET_channel_destroy (s->channel);
+    s->channel = NULL;
+    prepare_client_end_notification (s);
+    return;
+  }
+
+  e =
+    GNUNET_MQ_msg (msg,
+                   GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION);
+  GNUNET_MQ_env_set_options (e, GNUNET_MQ_PRIO_CRITICAL_CONTROL);
+  msg->session_id = s->session_id;
+  GNUNET_MQ_send (s->cadet_mq, e);
+}
+
+
+/**
+ * We're receiving additional set data. Check if
+ * @a msg is well-formed.
+ *
+ * @param cls client identification of the client
+ * @param msg the actual message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+static int
+check_alice_client_message_multipart (
+  void *cls,
+  const struct ComputationBobCryptodataMultipartMessage *msg)
+{
+  struct AliceServiceSession *s = cls;
+  uint32_t contained_count;
+  uint16_t msize;
+
+  msize = ntohs (msg->header.size);
+  contained_count = ntohl (msg->element_count_contained);
+  if ((msize !=
+       (sizeof(struct ComputationBobCryptodataMultipartMessage)
+        + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))) ||
+      (0 == contained_count) ||
+      (s->total == s->client_received_element_count) ||
+      (s->total < s->client_received_element_count + contained_count))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * We're receiving additional set data. Add it to our
+ * set and if we are done, initiate the transaction.
+ *
+ * @param cls client identification of the client
+ * @param msg the actual message
+ */
+static void
+handle_alice_client_message_multipart (
+  void *cls,
+  const struct ComputationBobCryptodataMultipartMessage *msg)
+{
+  struct AliceServiceSession *s = cls;
+  uint32_t contained_count;
+  const struct GNUNET_SCALARPRODUCT_Element *elements;
+  struct GNUNET_SETI_Element set_elem;
+  struct GNUNET_SCALARPRODUCT_Element *elem;
+
+  contained_count = ntohl (msg->element_count_contained);
+  s->client_received_element_count += contained_count;
+  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
+  for (uint32_t i = 0; i < contained_count; i++)
+  {
+    elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
+    GNUNET_memcpy (elem,
+                   &elements[i],
+                   sizeof(struct GNUNET_SCALARPRODUCT_Element));
+    if (GNUNET_SYSERR == GNUNET_CONTAINER_multihashmap_put (
+          s->intersected_elements,
+          &elem->key,
+          elem,
+          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+    {
+      GNUNET_break (0);
+      GNUNET_free (elem);
+      continue;
+    }
+    set_elem.data = &elem->key;
+    set_elem.size = sizeof(elem->key);
+    set_elem.element_type = 0;
+    GNUNET_SETI_add_element (s->intersection_set, &set_elem, NULL, NULL);
+    s->used_element_count++;
+  }
+  GNUNET_SERVICE_client_continue (s->client);
+  if (s->total != s->client_received_element_count)
+  {
+    /* more to come */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received client multipart data, waiting for more!\n");
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Launching computation\n");
+  client_request_complete_alice (s);
+}
+
+
+/**
+ * Handler for Alice's client request message.
+ * Check that @a msg is well-formed.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+static int
+check_alice_client_message (void *cls,
+                            const struct AliceComputationMessage *msg)
+{
+  struct AliceServiceSession *s = cls;
+  uint16_t msize;
+  uint32_t total_count;
+  uint32_t contained_count;
+
+  if (NULL != s->intersected_elements)
+  {
+    /* only one concurrent session per client connection allowed,
+       simplifies logic a lot... */
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  msize = ntohs (msg->header.size);
+  total_count = ntohl (msg->element_count_total);
+  contained_count = ntohl (msg->element_count_contained);
+  if ((0 == total_count) || (0 == contained_count) ||
+      (msize !=
+       (sizeof(struct AliceComputationMessage)
+        + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handler for Alice's client request message.
+ * We are doing request-initiation to compute a scalar product with a peer.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ */
+static void
+handle_alice_client_message (void *cls,
+                             const struct AliceComputationMessage *msg)
+{
+  struct AliceServiceSession *s = cls;
+  uint32_t contained_count;
+  uint32_t total_count;
+  const struct GNUNET_SCALARPRODUCT_Element *elements;
+  struct GNUNET_SETI_Element set_elem;
+  struct GNUNET_SCALARPRODUCT_Element *elem;
+
+  total_count = ntohl (msg->element_count_total);
+  contained_count = ntohl (msg->element_count_contained);
+  s->peer = msg->peer;
+  s->status = GNUNET_SCALARPRODUCT_STATUS_ACTIVE;
+  s->total = total_count;
+  s->client_received_element_count = contained_count;
+  s->session_id = msg->session_key;
+  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
+  s->intersected_elements =
+    GNUNET_CONTAINER_multihashmap_create (s->total,
+                                          GNUNET_YES);
+  s->intersection_set = GNUNET_SETI_create (cfg);
+  for (uint32_t i = 0; i < contained_count; i++)
+  {
+    if (0 == GNUNET_ntohll (elements[i].value))
+      continue;
+    elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
+    *elem = elements[i];
+    if (GNUNET_SYSERR ==
+        GNUNET_CONTAINER_multihashmap_put (
+          s->intersected_elements,
+          &elem->key,
+          elem,
+          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+    {
+      /* element with same key encountered twice! */
+      GNUNET_break (0);
+      GNUNET_free (elem);
+      continue;
+    }
+    set_elem.data = &elem->key;
+    set_elem.size = sizeof(elem->key);
+    set_elem.element_type = 0;
+    GNUNET_SETI_add_element (s->intersection_set,
+                             &set_elem,
+                             NULL,
+                             NULL);
+    s->used_element_count++;
+  }
+  GNUNET_SERVICE_client_continue (s->client);
+  if (s->total != s->client_received_element_count)
+  {
+    /* wait for multipart msg */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received partial client request, waiting for more!\n");
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Launching computation\n");
+  client_request_complete_alice (s);
+}
+
+
+/**
+ * Task run during shutdown.
+ *
+ * @param cls unused
+ * @param tc unused
+ */
+static void
+shutdown_task (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Shutting down, initiating cleanup.\n");
+  // FIXME: we have to cut our connections to CADET first!
+  if (NULL != my_cadet)
+  {
+    GNUNET_CADET_disconnect (my_cadet);
+    my_cadet = NULL;
+  }
+  if (NULL != edc)
+  {
+    GNUNET_CRYPTO_ecc_dlog_release (edc);
+    edc = NULL;
+  }
+}
+
+
+/**
+ * A client connected.
+ *
+ * Setup the associated data structure.
+ *
+ * @param cls closure, NULL
+ * @param client identification of the client
+ * @param mq message queue to communicate with @a client
+ * @return our `struct AliceServiceSession`
+ */
+static void *
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *client,
+                   struct GNUNET_MQ_Handle *mq)
+{
+  struct AliceServiceSession *s;
+
+  s = GNUNET_new (struct AliceServiceSession);
+  s->client = client;
+  s->client_mq = mq;
+  return s;
+}
+
+
+/**
+ * A client disconnected.
+ *
+ * Remove the associated session(s), release data structures
+ * and cancel pending outgoing transmissions to the client.
+ *
+ * @param cls closure, NULL
+ * @param client identification of the client
+ * @param app_cls our `struct AliceServiceSession`
+ */
+static void
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *app_cls)
+{
+  struct AliceServiceSession *s = app_cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Client %p disconnected from us.\n",
+              client);
+  s->client = NULL;
+  s->client_mq = NULL;
+  destroy_service_session (s);
+}
+
+
+/**
+ * Initialization of the program and message handlers
+ *
+ * @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)
+{
+  cfg = c;
+  edc = GNUNET_CRYPTO_ecc_dlog_prepare (MAX_RESULT,
+                                        MAX_RAM);
+  /* Select a random 'a' value for Alice */
+  GNUNET_CRYPTO_ecc_rnd_mpi (&my_privkey,
+                             &my_privkey_inv);
+  my_cadet = GNUNET_CADET_connect (cfg);
+  if (NULL == my_cadet)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Connect to CADET failed\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
+                                 NULL);
+}
+
+
+/**
+ * Define "main" method using service macro.
+ */
+GNUNET_SERVICE_MAIN (
+  "scalarproduct-alice",
+  GNUNET_SERVICE_OPTION_NONE,
+  &run,
+  &client_connect_cb,
+  &client_disconnect_cb,
+  NULL,
+  GNUNET_MQ_hd_var_size (alice_client_message,
+                         GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE,
+                         struct AliceComputationMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (
+    alice_client_message_multipart,
+    GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_ALICE,
+    struct ComputationBobCryptodataMultipartMessage,
+    NULL),
+  GNUNET_MQ_handler_end ());
+
+
+/* end of gnunet-service-scalarproduct-ecc_alice.c */
diff --git a/src/contrib/service/scalarproduct/gnunet-service-scalarproduct-ecc_bob.c b/src/contrib/service/scalarproduct/gnunet-service-scalarproduct-ecc_bob.c
new file mode 100644
index 000000000..1945f1937
--- /dev/null
+++ b/src/contrib/service/scalarproduct/gnunet-service-scalarproduct-ecc_bob.c
@@ -0,0 +1,1060 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013-2017, 2021 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file scalarproduct/gnunet-service-scalarproduct-ecc_bob.c
+ * @brief scalarproduct service implementation
+ * @author Christian M. Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include <limits.h>
+#include <gcrypt.h>
+#include "gnunet_util_lib.h"
+#include "gnunet_core_service.h"
+#include "gnunet_cadet_service.h"
+#include "gnunet_applications.h"
+#include "gnunet_protocols.h"
+#include "gnunet_scalarproduct_service.h"
+#include "gnunet_seti_service.h"
+#include "scalarproduct.h"
+#include "gnunet-service-scalarproduct-ecc.h"
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "scalarproduct-bob", __VA_ARGS__)
+
+
+/**
+ * An encrypted element key-value pair.
+ */
+struct MpiElement
+{
+  /**
+   * Key used to identify matching pairs of values to multiply.
+   * Points into an existing data structure, to avoid copying
+   * and doubling memory use.
+   */
+  const struct GNUNET_HashCode *key;
+
+  /**
+   * Value represented (a).
+   */
+  int64_t value;
+};
+
+
+/**
+ * A scalarproduct session which tracks an offer for a
+ * multiplication service by a local client.
+ */
+struct BobServiceSession
+{
+  /**
+   * The client this request is related to.
+   */
+  struct GNUNET_SERVICE_Client *client;
+
+  /**
+   * Client message queue.
+   */
+  struct GNUNET_MQ_Handle *client_mq;
+
+  /**
+   * All non-0-value'd elements transmitted to us.
+   */
+  struct GNUNET_CONTAINER_MultiHashMap *intersected_elements;
+
+  /**
+   * Set of elements for which we will be conducting an intersection.
+   * The resulting elements are then used for computing the scalar product.
+   */
+  struct GNUNET_SETI_Handle *intersection_set;
+
+  /**
+   * Set of elements for which will conduction an intersection.
+   * the resulting elements are then used for computing the scalar product.
+   */
+  struct GNUNET_SETI_OperationHandle *intersection_op;
+
+  /**
+   * Our open port.
+   */
+  struct GNUNET_CADET_Port *port;
+
+  /**
+   * b(Bob)
+   */
+  struct MpiElement *sorted_elements;
+
+  /**
+   * Product of the g_i^{b_i}
+   */
+  struct GNUNET_CRYPTO_EccPoint prod_g_i_b_i;
+
+  /**
+   * Product of the h_i^{b_i}
+   */
+  struct GNUNET_CRYPTO_EccPoint prod_h_i_b_i;
+
+  /**
+   * How many elements will be supplied in total from the client.
+   */
+  uint32_t total;
+
+  /**
+   * Already transferred elements (received) for multipart
+   * messages from client. Always less than @e total.
+   */
+  uint32_t client_received_element_count;
+
+  /**
+   * How many elements actually are used for the scalar product.
+   * Size of the arrays in @e r and @e r_prime.  Also sometimes
+   * used as an index into the arrays during construction.
+   */
+  uint32_t used_element_count;
+
+  /**
+   * Counts the number of values received from Alice by us.
+   * Always less than @e used_element_count.
+   */
+  uint32_t cadet_received_element_count;
+
+  /**
+   * State of this session.   In
+   * #GNUNET_SCALARPRODUCT_STATUS_ACTIVE while operation is
+   * ongoing, afterwards in #GNUNET_SCALARPRODUCT_STATUS_SUCCESS or
+   * #GNUNET_SCALARPRODUCT_STATUS_FAILURE.
+   */
+  enum GNUNET_SCALARPRODUCT_ResponseStatus status;
+
+  /**
+   * Are we already in #destroy_service_session()?
+   */
+  int in_destroy;
+
+  /**
+   * The CADET channel.
+   */
+  struct GNUNET_CADET_Channel *channel;
+
+  /**
+   * Originator's peer identity. (Only for diagnostics.)
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /**
+   * (hopefully) unique transaction ID
+   */
+  struct GNUNET_HashCode session_id;
+
+  /**
+   * The message queue for this channel.
+   */
+  struct GNUNET_MQ_Handle *cadet_mq;
+};
+
+
+/**
+ * GNUnet configuration handle
+ */
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Handle to the CADET service.
+ */
+static struct GNUNET_CADET_Handle *my_cadet;
+
+/**
+ * Context for DLOG operations on a curve.
+ */
+static struct GNUNET_CRYPTO_EccDlogContext *edc;
+
+
+/**
+ * Callback used to free the elements in the map.
+ *
+ * @param cls NULL
+ * @param key key of the element
+ * @param value the value to free
+ */
+static int
+free_element_cb (void *cls,
+                 const struct GNUNET_HashCode *key,
+                 void *value)
+{
+  struct GNUNET_SCALARPRODUCT_Element *element = value;
+
+  GNUNET_free (element);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Destroy session state, we are done with it.
+ *
+ * @param s the session to free elements from
+ */
+static void
+destroy_service_session (struct BobServiceSession *s)
+{
+  if (GNUNET_YES == s->in_destroy)
+    return;
+  s->in_destroy = GNUNET_YES;
+  if (NULL != s->client)
+  {
+    struct GNUNET_SERVICE_Client *c = s->client;
+
+    s->client = NULL;
+    GNUNET_SERVICE_client_drop (c);
+  }
+  if (NULL != s->intersected_elements)
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (s->intersected_elements,
+                                           &free_element_cb,
+                                           NULL);
+    GNUNET_CONTAINER_multihashmap_destroy (s->intersected_elements);
+    s->intersected_elements = NULL;
+  }
+  if (NULL != s->intersection_op)
+  {
+    GNUNET_SETI_operation_cancel (s->intersection_op);
+    s->intersection_op = NULL;
+  }
+  if (NULL != s->intersection_set)
+  {
+    GNUNET_SETI_destroy (s->intersection_set);
+    s->intersection_set = NULL;
+  }
+  if (NULL != s->sorted_elements)
+  {
+    GNUNET_free (s->sorted_elements);
+    s->sorted_elements = NULL;
+  }
+  if (NULL != s->port)
+  {
+    GNUNET_CADET_close_port (s->port);
+    s->port = NULL;
+  }
+  if (NULL != s->channel)
+  {
+    GNUNET_CADET_channel_destroy (s->channel);
+    s->channel = NULL;
+  }
+  GNUNET_free (s);
+}
+
+
+/**
+ * Notify the client that the session has succeeded or failed.  This
+ * message gets sent to Bob's client if the operation completed or
+ * Alice disconnected.
+ *
+ * @param session the associated client session to fail or succeed
+ */
+static void
+prepare_client_end_notification (struct BobServiceSession *session)
+{
+  struct ClientResponseMessage *msg;
+  struct GNUNET_MQ_Envelope *e;
+
+  if (NULL == session->client_mq)
+    return; /* no client left to be notified */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending session-end notification with status %d to client for session %s\n",
+              session->status,
+              GNUNET_h2s (&session->session_id));
+  e = GNUNET_MQ_msg (msg,
+                     GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT);
+  msg->range = 0;
+  msg->product_length = htonl (0);
+  msg->status = htonl (session->status);
+  GNUNET_MQ_send (session->client_mq,
+                  e);
+}
+
+
+/**
+ * Function called whenever a channel is destroyed.  Should clean up
+ * any associated state.
+ *
+ * It must NOT call #GNUNET_CADET_channel_destroy() on the channel.
+ *
+ * @param cls the `struct BobServiceSession`
+ * @param channel connection to the other end (henceforth invalid)
+ */
+static void
+cb_channel_destruction (void *cls,
+                        const struct GNUNET_CADET_Channel *channel)
+{
+  struct BobServiceSession *s = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Peer disconnected, terminating session %s with peer %s\n",
+              GNUNET_h2s (&s->session_id),
+              GNUNET_i2s (&s->peer));
+  s->channel = NULL;
+  if (GNUNET_SCALARPRODUCT_STATUS_ACTIVE == s->status)
+  {
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    prepare_client_end_notification (s);
+  }
+  destroy_service_session (s);
+}
+
+
+/**
+ * MQ finished giving our last message to CADET, now notify
+ * the client that we are finished.
+ */
+static void
+bob_cadet_done_cb (void *cls)
+{
+  struct BobServiceSession *session = cls;
+
+  session->status = GNUNET_SCALARPRODUCT_STATUS_SUCCESS;
+  prepare_client_end_notification (session);
+}
+
+
+/**
+ * Bob generates the response message to be sent to Alice.
+ *
+ * @param s the associated requesting session with Alice
+ */
+static void
+transmit_bobs_cryptodata_message (struct BobServiceSession *s)
+{
+  struct EccBobCryptodataMessage *msg;
+  struct GNUNET_MQ_Envelope *e;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending response to Alice\n");
+  e = GNUNET_MQ_msg (msg,
+                     GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA);
+  msg->contained_element_count = htonl (2);
+  msg->prod_g_i_b_i = s->prod_g_i_b_i;
+  msg->prod_h_i_b_i = s->prod_h_i_b_i;
+  GNUNET_MQ_notify_sent (e,
+                         &bob_cadet_done_cb,
+                         s);
+  GNUNET_MQ_send (s->cadet_mq,
+                  e);
+}
+
+
+/**
+ * Iterator to copy over messages from the hash map
+ * into an array for sorting.
+ *
+ * @param cls the `struct AliceServiceSession *`
+ * @param key the key (unused)
+ * @param value the `struct GNUNET_SCALARPRODUCT_Element *`
+ */
+static int
+copy_element_cb (void *cls,
+                 const struct GNUNET_HashCode *key,
+                 void *value)
+{
+  struct BobServiceSession *s = cls;
+  struct GNUNET_SCALARPRODUCT_Element *e = value;
+
+  s->sorted_elements[s->used_element_count].value = (int64_t) GNUNET_ntohll (
+    e->value);
+  s->sorted_elements[s->used_element_count].key = &e->key;
+  s->used_element_count++;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Compare two `struct MpiValue`s by key for sorting.
+ *
+ * @param a pointer to first `struct MpiValue *`
+ * @param b pointer to first `struct MpiValue *`
+ * @return -1 for a < b, 0 for a=b, 1 for a > b.
+ * TODO: code duplication with Alice!
+ */
+static int
+element_cmp (const void *a,
+             const void *b)
+{
+  const struct MpiElement *ma = a;
+  const struct MpiElement *mb = b;
+
+  return GNUNET_CRYPTO_hash_cmp (ma->key,
+                                 mb->key);
+}
+
+
+/**
+ * Check a multipart-chunk of a request from another service to
+ * calculate a scalarproduct with us.
+ *
+ * @param cls closure (set from #GNUNET_CADET_connect)
+ * @param msg the actual message
+ * @return #GNUNET_OK to keep the connection open,
+ *         #GNUNET_SYSERR to close it (signal serious error)
+ */
+static int
+check_alices_cryptodata_message (void *cls,
+                                 const struct EccAliceCryptodataMessage *msg)
+{
+  struct BobServiceSession *s = cls;
+  uint32_t contained_elements;
+  size_t msg_length;
+  uint16_t msize;
+  unsigned int max;
+
+  msize = ntohs (msg->header.size);
+  if (msize <= sizeof(struct EccAliceCryptodataMessage))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  contained_elements = ntohl (msg->contained_element_count);
+  /* Our intersection may still be ongoing, but this is nevertheless
+     an upper bound on the required array size */
+  max = GNUNET_CONTAINER_multihashmap_size (s->intersected_elements);
+  msg_length = sizeof(struct EccAliceCryptodataMessage)
+               + contained_elements * sizeof(struct GNUNET_CRYPTO_EccPoint) * 2;
+  if ((msize != msg_length) ||
+      (0 == contained_elements) ||
+      (contained_elements > UINT16_MAX) ||
+      (max < contained_elements + s->cadet_received_element_count))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle a multipart-chunk of a request from another service to
+ * calculate a scalarproduct with us.
+ *
+ * @param cls closure (set from #GNUNET_CADET_connect)
+ * @param msg the actual message
+ */
+static void
+handle_alices_cryptodata_message (void *cls,
+                                  const struct EccAliceCryptodataMessage *msg)
+{
+  struct BobServiceSession *s = cls;
+  const struct GNUNET_CRYPTO_EccPoint *payload;
+  uint32_t contained_elements;
+  unsigned int max;
+  const struct GNUNET_CRYPTO_EccPoint *g_i;
+  const struct GNUNET_CRYPTO_EccPoint *h_i;
+  struct GNUNET_CRYPTO_EccPoint g_i_b_i;
+  struct GNUNET_CRYPTO_EccPoint h_i_b_i;
+
+  contained_elements = ntohl (msg->contained_element_count);
+  max = GNUNET_CONTAINER_multihashmap_size (s->intersected_elements);
+  /* sort our vector for the computation */
+  if (NULL == s->sorted_elements)
+  {
+    s->sorted_elements
+      = GNUNET_new_array (GNUNET_CONTAINER_multihashmap_size (
+                            s->intersected_elements),
+                          struct MpiElement);
+    s->used_element_count = 0;
+    GNUNET_CONTAINER_multihashmap_iterate (s->intersected_elements,
+                                           &copy_element_cb,
+                                           s);
+    qsort (s->sorted_elements,
+           s->used_element_count,
+           sizeof(struct MpiElement),
+           &element_cmp);
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received %u crypto values from Alice\n",
+              (unsigned int) contained_elements);
+  payload = (const struct GNUNET_CRYPTO_EccPoint *) &msg[1];
+
+  for (unsigned int i = 0; i < contained_elements; i++)
+  {
+    int64_t val = s->sorted_elements[i + s->cadet_received_element_count].value;
+    struct GNUNET_CRYPTO_EccScalar vali;
+
+    GNUNET_assert (INT64_MIN != val);
+    GNUNET_CRYPTO_ecc_scalar_from_int (val > 0 ? val : -val,
+                                       &vali);
+    if (val < 0)
+      crypto_core_ed25519_scalar_negate (vali.v,
+                                         vali.v);
+    g_i = &payload[i * 2];
+    /* g_i_b_i = g_i^vali */
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CRYPTO_ecc_pmul_mpi (g_i,
+                                               &vali,
+                                               &g_i_b_i));
+    h_i = &payload[i * 2 + 1];
+    /* h_i_b_i = h_i^vali */
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CRYPTO_ecc_pmul_mpi (h_i,
+                                               &vali,
+                                               &h_i_b_i));
+    if (0 == i + s->cadet_received_element_count)
+    {
+      /* first iteration, nothing to add */
+      s->prod_g_i_b_i = g_i_b_i;
+      s->prod_h_i_b_i = h_i_b_i;
+    }
+    else
+    {
+      /* further iterations, cummulate resulting value */
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CRYPTO_ecc_add (&s->prod_g_i_b_i,
+                                            &g_i_b_i,
+                                            &s->prod_g_i_b_i));
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CRYPTO_ecc_add (&s->prod_h_i_b_i,
+                                            &h_i_b_i,
+                                            &s->prod_h_i_b_i));
+    }
+  }
+  s->cadet_received_element_count += contained_elements;
+  if ((s->cadet_received_element_count == max) &&
+      (NULL == s->intersection_op))
+  {
+    /* intersection has finished also on our side, and
+       we got the full set, so we can proceed with the
+       CADET response(s) */
+    transmit_bobs_cryptodata_message (s);
+  }
+  GNUNET_CADET_receive_done (s->channel);
+}
+
+
+/**
+ * Callback for set operation results. Called for each element
+ * that needs to be removed from the result set.
+ *
+ * @param cls closure with the `struct BobServiceSession`
+ * @param element a result element, only valid if status is #GNUNET_SETI_STATUS_OK
+ * @param current_size current set size
+ * @param status what has happened with the set intersection?
+ */
+static void
+cb_intersection_element_removed (void *cls,
+                                 const struct GNUNET_SETI_Element *element,
+                                 uint64_t current_size,
+                                 enum GNUNET_SETI_Status status)
+{
+  struct BobServiceSession *s = cls;
+  struct GNUNET_SCALARPRODUCT_Element *se;
+
+  switch (status)
+  {
+  case GNUNET_SETI_STATUS_DEL_LOCAL:
+    /* this element has been removed from the set */
+    se = GNUNET_CONTAINER_multihashmap_get (s->intersected_elements,
+                                            element->data);
+    GNUNET_assert (NULL != se);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Removed element with key %s and value %lld\n",
+         GNUNET_h2s (&se->key),
+         (long long) GNUNET_ntohll (se->value));
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multihashmap_remove (
+                     s->intersected_elements,
+                     element->data,
+                     se));
+    GNUNET_free (se);
+    return;
+  case GNUNET_SETI_STATUS_DONE:
+    s->intersection_op = NULL;
+    GNUNET_break (NULL == s->intersection_set);
+    GNUNET_CADET_receive_done (s->channel);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Finished intersection, %d items remain\n",
+         GNUNET_CONTAINER_multihashmap_size (s->intersected_elements));
+    if (s->client_received_element_count ==
+        GNUNET_CONTAINER_multihashmap_size (s->intersected_elements))
+    {
+      /* CADET transmission from Alice is also already done,
+         start with our own reply */
+      transmit_bobs_cryptodata_message (s);
+    }
+    return;
+  case GNUNET_SETI_STATUS_FAILURE:
+    /* unhandled status code */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Set intersection failed!\n");
+    s->intersection_op = NULL;
+    if (NULL != s->intersection_set)
+    {
+      GNUNET_SETI_destroy (s->intersection_set);
+      s->intersection_set = NULL;
+    }
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    prepare_client_end_notification (s);
+    return;
+
+  default:
+    GNUNET_break (0);
+    return;
+  }
+}
+
+
+/**
+ * We've paired up a client session with an incoming CADET request.
+ * Initiate set intersection work.
+ *
+ * @param s client session to start intersection for
+ */
+static void
+start_intersection (struct BobServiceSession *s)
+{
+  struct GNUNET_HashCode set_sid;
+
+  GNUNET_CRYPTO_hash (&s->session_id,
+                      sizeof(struct GNUNET_HashCode),
+                      &set_sid);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Got session with key %s and %u elements, starting intersection.\n",
+              GNUNET_h2s (&s->session_id),
+              (unsigned int) s->total);
+
+  s->intersection_op
+    = GNUNET_SETI_prepare (&s->peer,
+                           &set_sid,
+                           NULL,
+                           (struct GNUNET_SETI_Option[]) { { 0 } },
+                           &cb_intersection_element_removed,
+                           s);
+  if (GNUNET_OK !=
+      GNUNET_SETI_commit (s->intersection_op,
+                          s->intersection_set))
+  {
+    GNUNET_break (0);
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    prepare_client_end_notification (s);
+    return;
+  }
+  GNUNET_SETI_destroy (s->intersection_set);
+  s->intersection_set = NULL;
+}
+
+
+/**
+ * Handle a request from Alice to calculate a scalarproduct with us (Bob).
+ *
+ * @param cls closure (set from #GNUNET_CADET_connect)
+ * @param msg the actual message
+ */
+static void
+handle_alices_computation_request (void *cls,
+                                   const struct EccServiceRequestMessage *msg)
+{
+  struct BobServiceSession *s = cls;
+
+  s->session_id = msg->session_id; // ??
+  if (s->client_received_element_count < s->total)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Alice ready, still waiting for Bob client data!\n");
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Both ready, launching intersection!\n");
+  start_intersection (s);
+}
+
+
+/**
+ * Function called for inbound channels on Bob's end.  Does some
+ * preliminary initialization, more happens after we get Alice's first
+ * message.
+ *
+ * @param cls our `struct BobServiceSession`
+ * @param channel new handle to the channel
+ * @param initiator peer that started the channel
+ * @return session associated with the channel
+ */
+static void *
+cb_channel_incoming (void *cls,
+                     struct GNUNET_CADET_Channel *channel,
+                     const struct GNUNET_PeerIdentity *initiator)
+{
+  struct BobServiceSession *s = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "New incoming channel from peer %s.\n",
+              GNUNET_i2s (initiator));
+  GNUNET_CADET_close_port (s->port);
+  s->port = NULL;
+  s->peer = *initiator;
+  s->channel = channel;
+  s->cadet_mq = GNUNET_CADET_get_mq (s->channel);
+  return s;
+}
+
+
+/**
+ * We're receiving additional set data. Check it is well-formed.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+static int
+check_bob_client_message_multipart (
+  void *cls,
+  const struct ComputationBobCryptodataMultipartMessage *msg)
+{
+  struct BobServiceSession *s = cls;
+  uint32_t contained_count;
+  uint16_t msize;
+
+  msize = ntohs (msg->header.size);
+  contained_count = ntohl (msg->element_count_contained);
+  if ((msize != (sizeof(struct ComputationBobCryptodataMultipartMessage)
+                 + contained_count * sizeof(struct
+                                            GNUNET_SCALARPRODUCT_Element))) ||
+      (0 == contained_count) ||
+      (UINT16_MAX < contained_count) ||
+      (s->total == s->client_received_element_count) ||
+      (s->total < s->client_received_element_count + contained_count))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * We're receiving additional set data. Add it to our
+ * set and if we are done, initiate the transaction.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ */
+static void
+handle_bob_client_message_multipart (
+  void *cls,
+  const struct ComputationBobCryptodataMultipartMessage *msg)
+{
+  struct BobServiceSession *s = cls;
+  uint32_t contained_count;
+  const struct GNUNET_SCALARPRODUCT_Element *elements;
+  struct GNUNET_SETI_Element set_elem;
+  struct GNUNET_SCALARPRODUCT_Element *elem;
+
+  contained_count = ntohl (msg->element_count_contained);
+  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
+  for (uint32_t i = 0; i < contained_count; i++)
+  {
+    elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
+    GNUNET_memcpy (elem,
+                   &elements[i],
+                   sizeof(struct GNUNET_SCALARPRODUCT_Element));
+    if (GNUNET_SYSERR ==
+        GNUNET_CONTAINER_multihashmap_put (s->intersected_elements,
+                                           &elem->key,
+                                           elem,
+                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+    {
+      GNUNET_break (0);
+      GNUNET_free (elem);
+      continue;
+    }
+    set_elem.data = &elem->key;
+    set_elem.size = sizeof(elem->key);
+    set_elem.element_type = 0;
+    GNUNET_SETI_add_element (s->intersection_set,
+                             &set_elem,
+                             NULL, NULL);
+  }
+  s->client_received_element_count += contained_count;
+  GNUNET_SERVICE_client_continue (s->client);
+  if (s->total != s->client_received_element_count)
+  {
+    /* more to come */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Request still partial, waiting for more client data!\n");
+    return;
+  }
+  if (NULL == s->channel)
+  {
+    /* no Alice waiting for this request, wait for Alice */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Client ready, still waiting for Alice!\n");
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Both ready, launching intersection!\n");
+  start_intersection (s);
+}
+
+
+/**
+ * Handler for Bob's a client request message.  Check @a msg is
+ * well-formed.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+static int
+check_bob_client_message (void *cls,
+                          const struct BobComputationMessage *msg)
+{
+  struct BobServiceSession *s = cls;
+  uint32_t contained_count;
+  uint32_t total_count;
+  uint16_t msize;
+
+  if (GNUNET_SCALARPRODUCT_STATUS_INIT != s->status)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  msize = ntohs (msg->header.size);
+  total_count = ntohl (msg->element_count_total);
+  contained_count = ntohl (msg->element_count_contained);
+  if ((0 == total_count) ||
+      (0 == contained_count) ||
+      (UINT16_MAX < contained_count) ||
+      (msize != (sizeof(struct BobComputationMessage)
+                 + contained_count * sizeof(struct
+                                            GNUNET_SCALARPRODUCT_Element))))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handler for Bob's a client request message.  Bob is in the response
+ * role, keep the values + session and waiting for a matching session
+ * or process a waiting request from Alice.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ */
+static void
+handle_bob_client_message (void *cls,
+                           const struct BobComputationMessage *msg)
+{
+  struct BobServiceSession *s = cls;
+  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
+    GNUNET_MQ_hd_fixed_size (alices_computation_request,
+                             GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION,
+                             struct EccServiceRequestMessage,
+                             s),
+    GNUNET_MQ_hd_var_size (alices_cryptodata_message,
+                           GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA,
+                           struct EccAliceCryptodataMessage,
+                           s),
+    GNUNET_MQ_handler_end ()
+  };
+  uint32_t contained_count;
+  uint32_t total_count;
+  const struct GNUNET_SCALARPRODUCT_Element *elements;
+  struct GNUNET_SETI_Element set_elem;
+  struct GNUNET_SCALARPRODUCT_Element *elem;
+
+  total_count = ntohl (msg->element_count_total);
+  contained_count = ntohl (msg->element_count_contained);
+
+  s->status = GNUNET_SCALARPRODUCT_STATUS_ACTIVE;
+  s->total = total_count;
+  s->client_received_element_count = contained_count;
+  s->session_id = msg->session_key;
+  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
+  s->intersected_elements
+    = GNUNET_CONTAINER_multihashmap_create (s->total,
+                                            GNUNET_YES);
+  s->intersection_set = GNUNET_SETI_create (cfg);
+  for (uint32_t i = 0; i < contained_count; i++)
+  {
+    if (0 == GNUNET_ntohll (elements[i].value))
+      continue;
+    elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
+    GNUNET_memcpy (elem,
+                   &elements[i],
+                   sizeof(struct GNUNET_SCALARPRODUCT_Element));
+    if (GNUNET_SYSERR ==
+        GNUNET_CONTAINER_multihashmap_put (s->intersected_elements,
+                                           &elem->key,
+                                           elem,
+                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+    {
+      GNUNET_break (0);
+      GNUNET_free (elem);
+      continue;
+    }
+    set_elem.data = &elem->key;
+    set_elem.size = sizeof(elem->key);
+    set_elem.element_type = 0;
+    GNUNET_SETI_add_element (s->intersection_set,
+                             &set_elem,
+                             NULL, NULL);
+    s->used_element_count++;
+  }
+  GNUNET_SERVICE_client_continue (s->client);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received client request, opening port %s!\n",
+              GNUNET_h2s (&msg->session_key));
+  s->port = GNUNET_CADET_open_port (my_cadet,
+                                    &msg->session_key,
+                                    &cb_channel_incoming,
+                                    s,
+                                    NULL,
+                                    &cb_channel_destruction,
+                                    cadet_handlers);
+  if (NULL == s->port)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (s->client);
+    return;
+  }
+}
+
+
+/**
+ * Task run during shutdown.
+ *
+ * @param cls unused
+ */
+static void
+shutdown_task (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Shutting down, initiating cleanup.\n");
+  // FIXME: we have to cut our connections to CADET first!
+  if (NULL != my_cadet)
+  {
+    GNUNET_CADET_disconnect (my_cadet);
+    my_cadet = NULL;
+  }
+  if (NULL != edc)
+  {
+    GNUNET_CRYPTO_ecc_dlog_release (edc);
+    edc = NULL;
+  }
+}
+
+
+/**
+ * A client connected.
+ *
+ * Setup the associated data structure.
+ *
+ * @param cls closure, NULL
+ * @param client identification of the client
+ * @param mq message queue to communicate with @a client
+ * @return our `struct BobServiceSession`
+ */
+static void *
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *client,
+                   struct GNUNET_MQ_Handle *mq)
+{
+  struct BobServiceSession *s;
+
+  s = GNUNET_new (struct BobServiceSession);
+  s->client = client;
+  s->client_mq = mq;
+  return s;
+}
+
+
+/**
+ * A client disconnected.
+ *
+ * Remove the associated session(s), release data structures
+ * and cancel pending outgoing transmissions to the client.
+ *
+ * @param cls closure, NULL
+ * @param client identification of the client
+ * @param app_cls our `struct BobServiceSession`
+ */
+static void
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *app_cls)
+{
+  struct BobServiceSession *s = app_cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Client disconnected from us.\n");
+  s->client = NULL;
+  destroy_service_session (s);
+}
+
+
+/**
+ * Initialization of the program and message handlers
+ *
+ * @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)
+{
+  cfg = c;
+  /* We don't really do DLOG, so we can setup with very minimal resources */
+  edc = GNUNET_CRYPTO_ecc_dlog_prepare (4 /* max value */,
+                                        2 /* RAM */);
+  my_cadet = GNUNET_CADET_connect (cfg);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
+                                 NULL);
+  if (NULL == my_cadet)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Connect to CADET failed\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+}
+
+
+/**
+ * Define "main" method using service macro.
+ */
+GNUNET_SERVICE_MAIN
+  ("scalarproduct-bob",
+  GNUNET_SERVICE_OPTION_NONE,
+  &run,
+  &client_connect_cb,
+  &client_disconnect_cb,
+  NULL,
+  GNUNET_MQ_hd_var_size (bob_client_message,
+                         GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB,
+                         struct BobComputationMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (bob_client_message_multipart,
+                         GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_BOB,
+                         struct ComputationBobCryptodataMultipartMessage,
+                         NULL),
+  GNUNET_MQ_handler_end ());
+
+
+/* end of gnunet-service-scalarproduct-ecc_bob.c */
diff --git a/src/contrib/service/scalarproduct/gnunet-service-scalarproduct.h b/src/contrib/service/scalarproduct/gnunet-service-scalarproduct.h
new file mode 100644
index 000000000..4e79afa2f
--- /dev/null
+++ b/src/contrib/service/scalarproduct/gnunet-service-scalarproduct.h
@@ -0,0 +1,142 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013, 2014 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 scalarproduct/gnunet-service-scalarproduct.h
+ * @brief scalarproduct service  P2P messages
+ * @author Christian M. Fuchs
+ * @author Christian Grothoff
+ */
+#ifndef GNUNET_SERVICE_SCALARPRODUCT_H
+#define GNUNET_SERVICE_SCALARPRODUCT_H
+
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * Message type passed from requesting service Alice to responding
+ * service Bob to initiate a request and make Bob participate in our
+ * protocol.  Afterwards, Bob is expected to perform the set
+ * intersection with Alice. Once that has succeeded, Alice will
+ * send a `struct AliceCryptodataMessage *`.  Bob is not expected
+ * to respond via CADET in the meantime.
+ */
+struct ServiceRequestMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SESSION_INITIALIZATION
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * For alignment. Always zero.
+   */
+  uint32_t reserved;
+
+  /**
+   * The transaction/session key used to identify a session
+   */
+  struct GNUNET_HashCode session_id;
+
+  /**
+   * Alice's public key
+   */
+  struct GNUNET_CRYPTO_PaillierPublicKey public_key;
+};
+
+
+/**
+ * Vector of Pallier-encrypted values sent by Alice to Bob
+ * (after set intersection).  Alice may send messages of this
+ * type repeatedly to transmit all values.
+ */
+struct AliceCryptodataMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_CRYPTODATA
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * How many elements we appended to this message? In NBO.
+   */
+  uint32_t contained_element_count GNUNET_PACKED;
+
+  /**
+   * struct GNUNET_CRYPTO_PaillierCiphertext[contained_element_count]
+   */
+};
+
+
+/**
+ * Message type passed from responding service Bob to responding
+ * service Alice to complete a request and allow Alice to compute the
+ * result.  If Bob's reply does not fit into this one message, the
+ * conversation may be continued with `struct BobCryptodataMultipartMessage`
+ * messages afterwards.
+ */
+struct BobCryptodataMessage
+{
+  /**
+   * GNUNET message header with type
+   * #GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * How many elements this individual message delivers (in NBO).
+   */
+  uint32_t contained_element_count GNUNET_PACKED;
+
+  /**
+   * followed by s | s' | k[i][perm]
+   */
+};
+
+
+/**
+ * Multipart Message type passed between to supply additional elements
+ * for the peer.  Send from Bob to Alice with additional elements
+ * of k[i][perm] after his `struct BobCryptodataMessage *`.
+ * Once all k-values have been transmitted, Bob is finished and
+ * Alice can transmit the final result to the client.
+ */
+struct BobCryptodataMultipartMessage
+{
+  /**
+   * GNUNET message header
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * How many elements we supply within this message? In NBO.
+   */
+  uint32_t contained_element_count GNUNET_PACKED;
+
+  /**
+   * Followed by `struct
+   * GNUNET_CRYPTO_PaillierCiphertext[contained_element_count]`
+   */
+};
+
+
+GNUNET_NETWORK_STRUCT_END
+
+
+#endif
diff --git a/src/contrib/service/scalarproduct/gnunet-service-scalarproduct_alice.c b/src/contrib/service/scalarproduct/gnunet-service-scalarproduct_alice.c
new file mode 100644
index 000000000..0149f45ba
--- /dev/null
+++ b/src/contrib/service/scalarproduct/gnunet-service-scalarproduct_alice.c
@@ -0,0 +1,1388 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013, 2014, 2017 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file scalarproduct/gnunet-service-scalarproduct_alice.c
+ * @brief scalarproduct service implementation
+ * @author Christian M. Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include <limits.h>
+#include <gcrypt.h>
+#include "gnunet_util_lib.h"
+#include "gnunet_core_service.h"
+#include "gnunet_cadet_service.h"
+#include "gnunet_applications.h"
+#include "gnunet_protocols.h"
+#include "gnunet_scalarproduct_service.h"
+#include "gnunet_seti_service.h"
+#include "scalarproduct.h"
+#include "gnunet-service-scalarproduct.h"
+#include "gnunet_constants.h"
+
+#define LOG(kind, ...) \
+  GNUNET_log_from (kind, "scalarproduct-alice", __VA_ARGS__)
+
+/**
+ * An encrypted element key-value pair.
+ */
+struct MpiElement
+{
+  /**
+   * Key used to identify matching pairs of values to multiply.
+   * Points into an existing data structure, to avoid copying
+   * and doubling memory use.
+   */
+  const struct GNUNET_HashCode *key;
+
+  /**
+   * Value represented (a).
+   */
+  gcry_mpi_t value;
+};
+
+
+/**
+ * A scalarproduct session which tracks
+ * a request form the client to our final response.
+ */
+struct AliceServiceSession
+{
+  /**
+   * (hopefully) unique transaction ID
+   */
+  struct GNUNET_HashCode session_id;
+
+  /**
+   * Alice or Bob's peerID
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /**
+   * The client this request is related to.
+   */
+  struct GNUNET_SERVICE_Client *client;
+
+  /**
+   * The message queue for the client.
+   */
+  struct GNUNET_MQ_Handle *client_mq;
+
+  /**
+   * The message queue for CADET.
+   */
+  struct GNUNET_MQ_Handle *cadet_mq;
+
+  /**
+   * all non-0-value'd elements transmitted to us.
+   * Values are of type `struct GNUNET_SCALARPRODUCT_Element *`
+   */
+  struct GNUNET_CONTAINER_MultiHashMap *intersected_elements;
+
+  /**
+   * Set of elements for which will conduction an intersection.
+   * the resulting elements are then used for computing the scalar product.
+   */
+  struct GNUNET_SETI_Handle *intersection_set;
+
+  /**
+   * Set of elements for which will conduction an intersection.
+   * the resulting elements are then used for computing the scalar product.
+   */
+  struct GNUNET_SETI_OperationHandle *intersection_op;
+
+  /**
+   * Handle to Alice's Intersection operation listening for Bob
+   */
+  struct GNUNET_SETI_ListenHandle *intersection_listen;
+
+  /**
+   * channel-handle associated with our cadet handle
+   */
+  struct GNUNET_CADET_Channel *channel;
+
+  /**
+   * a(Alice), sorted array by key of length @e used_element_count.
+   */
+  struct MpiElement *sorted_elements;
+
+  /**
+   * Bob's permutation p of R
+   */
+  struct GNUNET_CRYPTO_PaillierCiphertext *r;
+
+  /**
+   * Bob's permutation q of R
+   */
+  struct GNUNET_CRYPTO_PaillierCiphertext *r_prime;
+
+  /**
+   * Bob's "s"
+   */
+  struct GNUNET_CRYPTO_PaillierCiphertext s;
+
+  /**
+   * Bob's "s'"
+   */
+  struct GNUNET_CRYPTO_PaillierCiphertext s_prime;
+
+  /**
+   * The computed scalar
+   */
+  gcry_mpi_t product;
+
+  /**
+   * How many elements we were supplied with from the client (total
+   * count before intersection).
+   */
+  uint32_t total;
+
+  /**
+   * How many elements actually are used for the scalar product.
+   * Size of the arrays in @e r and @e r_prime.  Sometimes also
+   * reset to 0 and used as a counter!
+   */
+  uint32_t used_element_count;
+
+  /**
+   * Already transferred elements from client to us.
+   * Less or equal than @e total.
+   */
+  uint32_t client_received_element_count;
+
+  /**
+   * Already transferred elements from Bob to us.
+   * Less or equal than @e total.
+   */
+  uint32_t cadet_received_element_count;
+
+  /**
+   * State of this session.   In
+   * #GNUNET_SCALARPRODUCT_STATUS_ACTIVE while operation is
+   * ongoing, afterwards in #GNUNET_SCALARPRODUCT_STATUS_SUCCESS or
+   * #GNUNET_SCALARPRODUCT_STATUS_FAILURE.
+   */
+  enum GNUNET_SCALARPRODUCT_ResponseStatus status;
+
+  /**
+   * Flag to prevent recursive calls to #destroy_service_session() from
+   * doing harm.
+   */
+  int in_destroy;
+};
+
+
+/**
+ * GNUnet configuration handle
+ */
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Service's own public key
+ */
+static struct GNUNET_CRYPTO_PaillierPublicKey my_pubkey;
+
+/**
+ * Service's own private key
+ */
+static struct GNUNET_CRYPTO_PaillierPrivateKey my_privkey;
+
+/**
+ * Service's offset for values that could possibly be negative but are plaintext for encryption.
+ */
+static gcry_mpi_t my_offset;
+
+/**
+ * Handle to the CADET service.
+ */
+static struct GNUNET_CADET_Handle *my_cadet;
+
+
+/**
+ * Iterator called to free elements.
+ *
+ * @param cls the `struct AliceServiceSession *` (unused)
+ * @param key the key (unused)
+ * @param value value to free
+ * @return #GNUNET_OK (continue to iterate)
+ */
+static int
+free_element_cb (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_SCALARPRODUCT_Element *e = value;
+
+  GNUNET_free (e);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Destroy session state, we are done with it.
+ *
+ * @param s the session to free elements from
+ */
+static void
+destroy_service_session (struct AliceServiceSession *s)
+{
+  if (GNUNET_YES == s->in_destroy)
+    return;
+  s->in_destroy = GNUNET_YES;
+  if (NULL != s->client)
+  {
+    struct GNUNET_SERVICE_Client *c = s->client;
+
+    s->client = NULL;
+    GNUNET_SERVICE_client_drop (c);
+  }
+  if (NULL != s->channel)
+  {
+    GNUNET_CADET_channel_destroy (s->channel);
+    s->channel = NULL;
+  }
+  if (NULL != s->intersected_elements)
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (s->intersected_elements,
+                                           &free_element_cb,
+                                           s);
+    GNUNET_CONTAINER_multihashmap_destroy (s->intersected_elements);
+    s->intersected_elements = NULL;
+  }
+  if (NULL != s->intersection_listen)
+  {
+    GNUNET_SETI_listen_cancel (s->intersection_listen);
+    s->intersection_listen = NULL;
+  }
+  if (NULL != s->intersection_op)
+  {
+    GNUNET_SETI_operation_cancel (s->intersection_op);
+    s->intersection_op = NULL;
+  }
+  if (NULL != s->intersection_set)
+  {
+    GNUNET_SETI_destroy (s->intersection_set);
+    s->intersection_set = NULL;
+  }
+  if (NULL != s->sorted_elements)
+  {
+    for (unsigned int i = 0; i < s->used_element_count; i++)
+      gcry_mpi_release (s->sorted_elements[i].value);
+    GNUNET_free (s->sorted_elements);
+    s->sorted_elements = NULL;
+  }
+  if (NULL != s->r)
+  {
+    GNUNET_free (s->r);
+    s->r = NULL;
+  }
+  if (NULL != s->r_prime)
+  {
+    GNUNET_free (s->r_prime);
+    s->r_prime = NULL;
+  }
+  if (NULL != s->product)
+  {
+    gcry_mpi_release (s->product);
+    s->product = NULL;
+  }
+  GNUNET_free (s);
+}
+
+
+/**
+ * Notify the client that the session has failed.  A message gets sent
+ * to Alice's client if we encountered any error.
+ *
+ * @param session the associated client session to fail or succeed
+ */
+static void
+prepare_client_end_notification (struct AliceServiceSession *session)
+{
+  struct ClientResponseMessage *msg;
+  struct GNUNET_MQ_Envelope *e;
+
+  if (NULL == session->client_mq)
+    return; /* no client left to be notified */
+  GNUNET_log (
+    GNUNET_ERROR_TYPE_DEBUG,
+    "Sending session-end notification with status %d to client for session %s\n",
+    session->status,
+    GNUNET_h2s (&session->session_id));
+  e = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT);
+  msg->product_length = htonl (0);
+  msg->status = htonl (session->status);
+  GNUNET_MQ_send (session->client_mq, e);
+}
+
+
+/**
+ * Prepare the final (positive) response we will send to Alice's
+ * client.
+ *
+ * @param s the session associated with our client.
+ */
+static void
+transmit_client_response (struct AliceServiceSession *s)
+{
+  struct ClientResponseMessage *msg;
+  struct GNUNET_MQ_Envelope *e;
+  unsigned char *product_exported = NULL;
+  size_t product_length = 0;
+  int32_t range;
+  gcry_error_t rc;
+  int sign;
+  gcry_mpi_t value;
+
+  if (NULL == s->product)
+  {
+    GNUNET_break (0);
+    prepare_client_end_notification (s);
+    return;
+  }
+  value = gcry_mpi_new (0);
+  sign = gcry_mpi_cmp_ui (s->product, 0);
+  if (0 > sign)
+  {
+    range = -1;
+    gcry_mpi_sub (value, value, s->product);
+  }
+  else if (0 < sign)
+  {
+    range = 1;
+    gcry_mpi_add (value, value, s->product);
+  }
+  else
+  {
+    /* result is exactly zero */
+    range = 0;
+  }
+  gcry_mpi_release (s->product);
+  s->product = NULL;
+
+  if ((0 != range) && (0 != (rc = gcry_mpi_aprint (GCRYMPI_FMT_STD,
+                                                   &product_exported,
+                                                   &product_length,
+                                                   value))))
+  {
+    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+    prepare_client_end_notification (s);
+    return;
+  }
+  gcry_mpi_release (value);
+  e = GNUNET_MQ_msg_extra (msg,
+                           product_length,
+                           GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT);
+  msg->status = htonl (GNUNET_SCALARPRODUCT_STATUS_SUCCESS);
+  msg->range = htonl (range);
+  msg->product_length = htonl (product_length);
+  if (NULL != product_exported)
+  {
+    GNUNET_memcpy (&msg[1], product_exported, product_length);
+    GNUNET_free (product_exported);
+  }
+  GNUNET_MQ_send (s->client_mq, e);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sent result to client, session %s has ended!\n",
+              GNUNET_h2s (&s->session_id));
+}
+
+
+/**
+ * Function called whenever a channel is destroyed.  Should clean up
+ * any associated state.
+ *
+ * It must NOT call #GNUNET_CADET_channel_destroy() on the channel.
+ *
+ * @param cls our `struct AliceServiceSession`
+ * @param channel connection to the other end (henceforth invalid)
+ */
+static void
+cb_channel_destruction (void *cls, const struct GNUNET_CADET_Channel *channel)
+{
+  struct AliceServiceSession *s = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Peer disconnected, terminating session %s with peer %s\n",
+              GNUNET_h2s (&s->session_id),
+              GNUNET_i2s (&s->peer));
+  if (GNUNET_SCALARPRODUCT_STATUS_ACTIVE == s->status)
+  {
+    /* We didn't get an answer yet, fail with error */
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    prepare_client_end_notification (s);
+  }
+  s->channel = NULL;
+}
+
+
+/**
+ * Computes the square sum over a vector of a given length.
+ *
+ * @param vector the vector to compute over
+ * @param length the length of the vector
+ * @return an MPI value containing the calculated sum, never NULL
+ */
+static gcry_mpi_t
+compute_square_sum_mpi_elements (const struct MpiElement *vector,
+                                 uint32_t length)
+{
+  gcry_mpi_t elem;
+  gcry_mpi_t sum;
+  uint32_t i;
+
+  GNUNET_assert (NULL != (sum = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (elem = gcry_mpi_new (0)));
+  for (i = 0; i < length; i++)
+  {
+    gcry_mpi_mul (elem, vector[i].value, vector[i].value);
+    gcry_mpi_add (sum, sum, elem);
+  }
+  gcry_mpi_release (elem);
+  return sum;
+}
+
+
+/**
+ * Computes the square sum over a vector of a given length.
+ *
+ * @param vector the vector to compute over
+ * @param length the length of the vector
+ * @return an MPI value containing the calculated sum, never NULL
+ */
+static gcry_mpi_t
+compute_square_sum (const gcry_mpi_t *vector, uint32_t length)
+{
+  gcry_mpi_t elem;
+  gcry_mpi_t sum;
+  uint32_t i;
+
+  GNUNET_assert (NULL != (sum = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (elem = gcry_mpi_new (0)));
+  for (i = 0; i < length; i++)
+  {
+    gcry_mpi_mul (elem, vector[i], vector[i]);
+    gcry_mpi_add (sum, sum, elem);
+  }
+  gcry_mpi_release (elem);
+  return sum;
+}
+
+
+/**
+ * Compute our scalar product, done by Alice
+ *
+ * @param session the session associated with this computation
+ * @return product as MPI, never NULL
+ */
+static gcry_mpi_t
+compute_scalar_product (struct AliceServiceSession *session)
+{
+  uint32_t count;
+  gcry_mpi_t t;
+  gcry_mpi_t u;
+  gcry_mpi_t u_prime;
+  gcry_mpi_t p;
+  gcry_mpi_t p_prime;
+  gcry_mpi_t tmp;
+  gcry_mpi_t r[session->used_element_count];
+  gcry_mpi_t r_prime[session->used_element_count];
+  gcry_mpi_t s;
+  gcry_mpi_t s_prime;
+  unsigned int i;
+
+  count = session->used_element_count;
+  // due to the introduced static offset S, we now also have to remove this
+  // from the E(a_pi)(+)E(-b_pi-r_pi) and E(a_qi)(+)E(-r_qi) twice each,
+  // the result is E((S + a_pi) + (S -b_pi-r_pi)) and E(S + a_qi + S - r_qi)
+  for (i = 0; i < count; i++)
+  {
+    r[i] = gcry_mpi_new (0);
+    GNUNET_CRYPTO_paillier_decrypt (&my_privkey,
+                                    &my_pubkey,
+                                    &session->r[i],
+                                    r[i]);
+    gcry_mpi_sub (r[i], r[i], my_offset);
+    gcry_mpi_sub (r[i], r[i], my_offset);
+    r_prime[i] = gcry_mpi_new (0);
+    GNUNET_CRYPTO_paillier_decrypt (&my_privkey,
+                                    &my_pubkey,
+                                    &session->r_prime[i],
+                                    r_prime[i]);
+    gcry_mpi_sub (r_prime[i], r_prime[i], my_offset);
+    gcry_mpi_sub (r_prime[i], r_prime[i], my_offset);
+  }
+
+  // calculate t = sum(ai)
+  t = compute_square_sum_mpi_elements (session->sorted_elements, count);
+  // calculate U
+  u = gcry_mpi_new (0);
+  tmp = compute_square_sum (r, count);
+  gcry_mpi_sub (u, u, tmp);
+  gcry_mpi_release (tmp);
+
+  // calculate U'
+  u_prime = gcry_mpi_new (0);
+  tmp = compute_square_sum (r_prime, count);
+  gcry_mpi_sub (u_prime, u_prime, tmp);
+
+  GNUNET_assert (p = gcry_mpi_new (0));
+  GNUNET_assert (p_prime = gcry_mpi_new (0));
+  GNUNET_assert (s = gcry_mpi_new (0));
+  GNUNET_assert (s_prime = gcry_mpi_new (0));
+
+  // compute P
+  GNUNET_CRYPTO_paillier_decrypt (&my_privkey, &my_pubkey, &session->s, s);
+  GNUNET_CRYPTO_paillier_decrypt (&my_privkey,
+                                  &my_pubkey,
+                                  &session->s_prime,
+                                  s_prime);
+
+  // compute P
+  gcry_mpi_add (p, s, t);
+  gcry_mpi_add (p, p, u);
+
+  // compute P'
+  gcry_mpi_add (p_prime, s_prime, t);
+  gcry_mpi_add (p_prime, p_prime, u_prime);
+
+  gcry_mpi_release (t);
+  gcry_mpi_release (u);
+  gcry_mpi_release (u_prime);
+  gcry_mpi_release (s);
+  gcry_mpi_release (s_prime);
+
+  // compute product
+  gcry_mpi_sub (p, p, p_prime);
+  gcry_mpi_release (p_prime);
+  tmp = gcry_mpi_set_ui (tmp, 2);
+  gcry_mpi_div (p, NULL, p, tmp, 0);
+
+  gcry_mpi_release (tmp);
+  for (i = 0; i < count; i++)
+  {
+    gcry_mpi_release (session->sorted_elements[i].value);
+    gcry_mpi_release (r[i]);
+    gcry_mpi_release (r_prime[i]);
+  }
+  GNUNET_free (session->sorted_elements);
+  session->sorted_elements = NULL;
+  GNUNET_free (session->r);
+  session->r = NULL;
+  GNUNET_free (session->r_prime);
+  session->r_prime = NULL;
+
+  return p;
+}
+
+
+/**
+ * Check a multipart chunk of a response we got from another service
+ * we wanted to calculate a scalarproduct with.
+ *
+ * @param cls the `struct AliceServiceSession`
+ * @param msg the actual message
+ * @return #GNUNET_OK to keep the connection open,
+ *         #GNUNET_SYSERR to close it (signal serious error)
+ */
+static int
+check_bobs_cryptodata_multipart (
+  void *cls,
+  const struct BobCryptodataMultipartMessage *msg)
+{
+  struct AliceServiceSession *s = cls;
+  uint32_t contained;
+  size_t msg_size;
+  size_t required_size;
+
+  msg_size = ntohs (msg->header.size);
+  contained = ntohl (msg->contained_element_count);
+  required_size =
+    sizeof(struct BobCryptodataMultipartMessage)
+    + 2 * contained * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext);
+  if ((required_size != msg_size) ||
+      (s->cadet_received_element_count + contained > s->used_element_count))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle a multipart chunk of a response we got from another service
+ * we wanted to calculate a scalarproduct with.
+ *
+ * @param cls the `struct AliceServiceSession`
+ * @param msg the actual message
+ */
+static void
+handle_bobs_cryptodata_multipart (
+  void *cls,
+  const struct BobCryptodataMultipartMessage *msg)
+{
+  struct AliceServiceSession *s = cls;
+  const struct GNUNET_CRYPTO_PaillierCiphertext *payload;
+  size_t i;
+  uint32_t contained;
+
+  contained = ntohl (msg->contained_element_count);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received %u additional crypto values from Bob\n",
+              (unsigned int) contained);
+
+  payload = (const struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
+  /* Convert each k[][perm] to its MPI_value */
+  for (i = 0; i < contained; i++)
+  {
+    GNUNET_memcpy (&s->r[s->cadet_received_element_count + i],
+                   &payload[2 * i],
+                   sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
+    GNUNET_memcpy (&s->r_prime[s->cadet_received_element_count + i],
+                   &payload[2 * i],
+                   sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
+  }
+  s->cadet_received_element_count += contained;
+  GNUNET_CADET_receive_done (s->channel);
+  if (s->cadet_received_element_count != s->used_element_count)
+    return; /* more to come */
+
+  s->product = compute_scalar_product (s);
+  transmit_client_response (s);
+}
+
+
+/**
+ * Check a response we got from another service we wanted to
+ * calculate a scalarproduct with.
+ *
+ * @param cls our `struct AliceServiceSession`
+ * @param msg the actual message
+ * @return #GNUNET_OK to keep the connection open,
+ *         #GNUNET_SYSERR to close it (we are done)
+ */
+static int
+check_bobs_cryptodata_message (void *cls,
+                               const struct BobCryptodataMessage *msg)
+{
+  struct AliceServiceSession *s = cls;
+  uint32_t contained;
+  uint16_t msg_size;
+  size_t required_size;
+
+  msg_size = ntohs (msg->header.size);
+  contained = ntohl (msg->contained_element_count);
+  required_size =
+    sizeof(struct BobCryptodataMessage)
+    + 2 * contained * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext)
+    + 2 * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext);
+  if ((msg_size != required_size) || (contained > UINT16_MAX) ||
+      (s->used_element_count < contained))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  if (NULL == s->sorted_elements)
+  {
+    /* we're not ready yet, how can Bob be? */
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  if (s->total != s->client_received_element_count)
+  {
+    /* we're not ready yet, how can Bob be? */
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle a response we got from another service we wanted to
+ * calculate a scalarproduct with.
+ *
+ * @param cls our `struct AliceServiceSession`
+ * @param msg the actual message
+ */
+static void
+handle_bobs_cryptodata_message (void *cls,
+                                const struct BobCryptodataMessage *msg)
+{
+  struct AliceServiceSession *s = cls;
+  const struct GNUNET_CRYPTO_PaillierCiphertext *payload;
+  uint32_t i;
+  uint32_t contained;
+
+  contained = ntohl (msg->contained_element_count);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received %u crypto values from Bob\n",
+              (unsigned int) contained);
+  payload = (const struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
+  GNUNET_memcpy (&s->s,
+                 &payload[0],
+                 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
+  GNUNET_memcpy (&s->s_prime,
+                 &payload[1],
+                 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
+  payload = &payload[2];
+
+  s->r = GNUNET_new_array (s->used_element_count,
+                           struct GNUNET_CRYPTO_PaillierCiphertext);
+  s->r_prime = GNUNET_new_array (s->used_element_count,
+                                 struct GNUNET_CRYPTO_PaillierCiphertext);
+  for (i = 0; i < contained; i++)
+  {
+    GNUNET_memcpy (&s->r[i],
+                   &payload[2 * i],
+                   sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
+    GNUNET_memcpy (&s->r_prime[i],
+                   &payload[2 * i + 1],
+                   sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
+  }
+  s->cadet_received_element_count = contained;
+  GNUNET_CADET_receive_done (s->channel);
+
+  if (s->cadet_received_element_count != s->used_element_count)
+  {
+    /* More to come */
+    return;
+  }
+  s->product = compute_scalar_product (s);
+  transmit_client_response (s);
+}
+
+
+/**
+ * Iterator to copy over messages from the hash map
+ * into an array for sorting.
+ *
+ * @param cls the `struct AliceServiceSession *`
+ * @param key the key (unused)
+ * @param value the `struct GNUNET_SCALARPRODUCT_Element *`
+ */
+static int
+copy_element_cb (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct AliceServiceSession *s = cls;
+  struct GNUNET_SCALARPRODUCT_Element *e = value;
+  gcry_mpi_t mval;
+  int64_t val;
+
+  mval = gcry_mpi_new (0);
+  val = (int64_t) GNUNET_ntohll (e->value);
+  if (0 > val)
+    gcry_mpi_sub_ui (mval, mval, -val);
+  else
+    gcry_mpi_add_ui (mval, mval, val);
+  s->sorted_elements[s->used_element_count].value = mval;
+  s->sorted_elements[s->used_element_count].key = &e->key;
+  s->used_element_count++;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Compare two `struct MpiValue`s by key for sorting.
+ *
+ * @param a pointer to first `struct MpiValue *`
+ * @param b pointer to first `struct MpiValue *`
+ * @return -1 for a < b, 0 for a=b, 1 for a > b.
+ */
+static int
+element_cmp (const void *a, const void *b)
+{
+  const struct MpiElement *ma = a;
+  const struct MpiElement *mb = b;
+
+  return GNUNET_CRYPTO_hash_cmp (ma->key, mb->key);
+}
+
+
+/**
+ * Maximum number of elements we can put into a single cryptodata
+ * message
+ */
+#define ELEMENT_CAPACITY                          \
+  ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1   \
+    - sizeof(struct AliceCryptodataMessage))       \
+   / sizeof(struct GNUNET_CRYPTO_PaillierCiphertext))
+
+
+/**
+ * Send the cryptographic data from Alice to Bob.
+ * Does nothing if we already transferred all elements.
+ *
+ * @param s the associated service session
+ */
+static void
+send_alices_cryptodata_message (struct AliceServiceSession *s)
+{
+  struct AliceCryptodataMessage *msg;
+  struct GNUNET_MQ_Envelope *e;
+  struct GNUNET_CRYPTO_PaillierCiphertext *payload;
+  unsigned int i;
+  uint32_t todo_count;
+  gcry_mpi_t a;
+  uint32_t off;
+
+  s->sorted_elements = GNUNET_malloc (
+    GNUNET_CONTAINER_multihashmap_size (s->intersected_elements)
+    * sizeof(struct MpiElement));
+  s->used_element_count = 0;
+  GNUNET_CONTAINER_multihashmap_iterate (s->intersected_elements,
+                                         &copy_element_cb,
+                                         s);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Finished intersection, %d items remain\n",
+       s->used_element_count);
+  qsort (s->sorted_elements,
+         s->used_element_count,
+         sizeof(struct MpiElement),
+         &element_cmp);
+  off = 0;
+  while (off < s->used_element_count)
+  {
+    todo_count = s->used_element_count - off;
+    if (todo_count > ELEMENT_CAPACITY)
+      todo_count = ELEMENT_CAPACITY;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending %u/%u crypto values to Bob\n",
+                (unsigned int) todo_count,
+                (unsigned int) s->used_element_count);
+
+    e =
+      GNUNET_MQ_msg_extra (msg,
+                           todo_count
+                           * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext),
+                           GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_CRYPTODATA);
+    msg->contained_element_count = htonl (todo_count);
+    payload = (struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
+    a = gcry_mpi_new (0);
+    for (i = off; i < off + todo_count; i++)
+    {
+      gcry_mpi_add (a, s->sorted_elements[i].value, my_offset);
+      GNUNET_assert (
+        3 ==
+        GNUNET_CRYPTO_paillier_encrypt (&my_pubkey, a, 3, &payload[i - off]));
+    }
+    gcry_mpi_release (a);
+    off += todo_count;
+    GNUNET_MQ_send (s->cadet_mq, e);
+  }
+}
+
+
+/**
+ * Callback for set operation results. Called for each element
+ * that should be removed from the result set, and then once
+ * to indicate that the set intersection operation is done.
+ *
+ * @param cls closure with the `struct AliceServiceSession`
+ * @param element a result element, only valid if status is #GNUNET_SETI_STATUS_OK
+ * @param current_size current set size
+ * @param status what has happened with the set intersection?
+ */
+static void
+cb_intersection_element_removed (void *cls,
+                                 const struct GNUNET_SETI_Element *element,
+                                 uint64_t current_size,
+                                 enum GNUNET_SETI_Status status)
+{
+  struct AliceServiceSession *s = cls;
+  struct GNUNET_SCALARPRODUCT_Element *se;
+
+  switch (status)
+  {
+  case GNUNET_SETI_STATUS_DEL_LOCAL:
+    /* this element has been removed from the set */
+    se = GNUNET_CONTAINER_multihashmap_get (s->intersected_elements,
+                                            element->data);
+    GNUNET_assert (NULL != se);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Intersection removed element with key %s and value %lld\n",
+         GNUNET_h2s (&se->key),
+         (long long) GNUNET_ntohll (se->value));
+    GNUNET_assert (
+      GNUNET_YES ==
+      GNUNET_CONTAINER_multihashmap_remove (s->intersected_elements,
+                                            element->data,
+                                            se));
+    GNUNET_free (se);
+    return;
+
+  case GNUNET_SETI_STATUS_DONE:
+    s->intersection_op = NULL;
+    if (NULL != s->intersection_set)
+    {
+      GNUNET_SETI_destroy (s->intersection_set);
+      s->intersection_set = NULL;
+    }
+    send_alices_cryptodata_message (s);
+    return;
+  case GNUNET_SETI_STATUS_FAILURE:
+    /* unhandled status code */
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Set intersection failed!\n");
+    if (NULL != s->intersection_listen)
+    {
+      GNUNET_SETI_listen_cancel (s->intersection_listen);
+      s->intersection_listen = NULL;
+    }
+    s->intersection_op = NULL;
+    if (NULL != s->intersection_set)
+    {
+      GNUNET_SETI_destroy (s->intersection_set);
+      s->intersection_set = NULL;
+    }
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    prepare_client_end_notification (s);
+    return;
+
+  default:
+    GNUNET_break (0);
+    return;
+  }
+}
+
+
+/**
+ * Called when another peer wants to do a set operation with the
+ * local peer. If a listen error occurs, the @a request is NULL.
+ *
+ * @param cls closure with the `struct AliceServiceSession *`
+ * @param other_peer the other peer
+ * @param context_msg message with application specific information from
+ *        the other peer
+ * @param request request from the other peer (never NULL), use GNUNET_SETI_accept()
+ *        to accept it, otherwise the request will be refused
+ *        Note that we can't just return value from the listen callback,
+ *        as it is also necessary to specify the set we want to do the
+ *        operation with, which sometimes can be derived from the context
+ *        message. It's necessary to specify the timeout.
+ */
+static void
+cb_intersection_request_alice (void *cls,
+                               const struct GNUNET_PeerIdentity *other_peer,
+                               const struct GNUNET_MessageHeader *context_msg,
+                               struct GNUNET_SETI_Request *request)
+{
+  struct AliceServiceSession *s = cls;
+
+  if (0 != GNUNET_memcmp (other_peer, &s->peer))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  s->intersection_op = GNUNET_SETI_accept (request,
+                                           (struct
+                                            GNUNET_SETI_Option[]){ { 0 } },
+                                           &cb_intersection_element_removed,
+                                           s);
+  if (NULL == s->intersection_op)
+  {
+    GNUNET_break (0);
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    prepare_client_end_notification (s);
+    return;
+  }
+  if (GNUNET_OK != GNUNET_SETI_commit (s->intersection_op, s->intersection_set))
+  {
+    GNUNET_break (0);
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    prepare_client_end_notification (s);
+    return;
+  }
+}
+
+
+/**
+ * Our client has finished sending us its multipart message.
+ *
+ * @param session the service session context
+ */
+static void
+client_request_complete_alice (struct AliceServiceSession *s)
+{
+  struct GNUNET_MQ_MessageHandler cadet_handlers[] =
+  { GNUNET_MQ_hd_var_size (bobs_cryptodata_message,
+                           GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA,
+                           struct BobCryptodataMessage,
+                           s),
+    GNUNET_MQ_hd_var_size (
+      bobs_cryptodata_multipart,
+      GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA_MULTIPART,
+      struct BobCryptodataMultipartMessage,
+      s),
+    GNUNET_MQ_handler_end () };
+  struct ServiceRequestMessage *msg;
+  struct GNUNET_MQ_Envelope *e;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Creating new channel for session with key %s.\n",
+              GNUNET_h2s (&s->session_id));
+  s->channel = GNUNET_CADET_channel_create (my_cadet,
+                                            s,
+                                            &s->peer,
+                                            &s->session_id,
+                                            NULL,
+                                            &cb_channel_destruction,
+                                            cadet_handlers);
+  if (NULL == s->channel)
+  {
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    prepare_client_end_notification (s);
+    return;
+  }
+  s->cadet_mq = GNUNET_CADET_get_mq (s->channel);
+  s->intersection_listen = GNUNET_SETI_listen (cfg,
+                                               &s->session_id,
+                                               &cb_intersection_request_alice,
+                                               s);
+  if (NULL == s->intersection_listen)
+  {
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    GNUNET_CADET_channel_destroy (s->channel);
+    s->channel = NULL;
+    prepare_client_end_notification (s);
+    return;
+  }
+
+  e = GNUNET_MQ_msg (msg,
+                     GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SESSION_INITIALIZATION);
+  msg->session_id = s->session_id;
+  msg->public_key = my_pubkey;
+  GNUNET_MQ_send (s->cadet_mq, e);
+}
+
+
+/**
+ * We're receiving additional set data. Check if
+ * @a msg is well-formed.
+ *
+ * @param cls client identification of the client
+ * @param msg the actual message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+static int
+check_alice_client_message_multipart (
+  void *cls,
+  const struct ComputationBobCryptodataMultipartMessage *msg)
+{
+  struct AliceServiceSession *s = cls;
+  uint32_t contained_count;
+  uint16_t msize;
+
+  msize = ntohs (msg->header.size);
+  contained_count = ntohl (msg->element_count_contained);
+  if ((msize !=
+       (sizeof(struct ComputationBobCryptodataMultipartMessage)
+        + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))) ||
+      (0 == contained_count) ||
+      (s->total == s->client_received_element_count) ||
+      (s->total < s->client_received_element_count + contained_count))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * We're receiving additional set data. Add it to our
+ * set and if we are done, initiate the transaction.
+ *
+ * @param cls client identification of the client
+ * @param msg the actual message
+ */
+static void
+handle_alice_client_message_multipart (
+  void *cls,
+  const struct ComputationBobCryptodataMultipartMessage *msg)
+{
+  struct AliceServiceSession *s = cls;
+  uint32_t contained_count;
+  const struct GNUNET_SCALARPRODUCT_Element *elements;
+  struct GNUNET_SETI_Element set_elem;
+  struct GNUNET_SCALARPRODUCT_Element *elem;
+
+  contained_count = ntohl (msg->element_count_contained);
+  s->client_received_element_count += contained_count;
+  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
+  for (uint32_t i = 0; i < contained_count; i++)
+  {
+    elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
+    GNUNET_memcpy (elem,
+                   &elements[i],
+                   sizeof(struct GNUNET_SCALARPRODUCT_Element));
+    if (GNUNET_SYSERR == GNUNET_CONTAINER_multihashmap_put (
+          s->intersected_elements,
+          &elem->key,
+          elem,
+          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+    {
+      GNUNET_break (0);
+      GNUNET_free (elem);
+      continue;
+    }
+    set_elem.data = &elem->key;
+    set_elem.size = sizeof(elem->key);
+    set_elem.element_type = 0;
+    GNUNET_SETI_add_element (s->intersection_set, &set_elem, NULL, NULL);
+    s->used_element_count++;
+  }
+  GNUNET_SERVICE_client_continue (s->client);
+  if (s->total != s->client_received_element_count)
+  {
+    /* more to come */
+    return;
+  }
+  client_request_complete_alice (s);
+}
+
+
+/**
+ * Handler for Alice's client request message.
+ * Check that @a msg is well-formed.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+static int
+check_alice_client_message (void *cls,
+                            const struct AliceComputationMessage *msg)
+{
+  struct AliceServiceSession *s = cls;
+  uint16_t msize;
+  uint32_t total_count;
+  uint32_t contained_count;
+
+  if (NULL != s->intersected_elements)
+  {
+    /* only one concurrent session per client connection allowed,
+       simplifies logic a lot... */
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  msize = ntohs (msg->header.size);
+  total_count = ntohl (msg->element_count_total);
+  contained_count = ntohl (msg->element_count_contained);
+  if ((0 == total_count) || (0 == contained_count) ||
+      (msize !=
+       (sizeof(struct AliceComputationMessage)
+        + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handler for Alice's client request message.
+ * We are doing request-initiation to compute a scalar product with a peer.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ */
+static void
+handle_alice_client_message (void *cls,
+                             const struct AliceComputationMessage *msg)
+{
+  struct AliceServiceSession *s = cls;
+  uint32_t contained_count;
+  uint32_t total_count;
+  const struct GNUNET_SCALARPRODUCT_Element *elements;
+  struct GNUNET_SETI_Element set_elem;
+  struct GNUNET_SCALARPRODUCT_Element *elem;
+
+  total_count = ntohl (msg->element_count_total);
+  contained_count = ntohl (msg->element_count_contained);
+  s->peer = msg->peer;
+  s->status = GNUNET_SCALARPRODUCT_STATUS_ACTIVE;
+  s->total = total_count;
+  s->client_received_element_count = contained_count;
+  s->session_id = msg->session_key;
+  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
+  s->intersected_elements =
+    GNUNET_CONTAINER_multihashmap_create (s->total, GNUNET_YES);
+  s->intersection_set = GNUNET_SETI_create (cfg);
+
+  for (uint32_t i = 0; i < contained_count; i++)
+  {
+    if (0 == GNUNET_ntohll (elements[i].value))
+      continue;
+    elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
+    GNUNET_memcpy (elem,
+                   &elements[i],
+                   sizeof(struct GNUNET_SCALARPRODUCT_Element));
+    if (GNUNET_SYSERR == GNUNET_CONTAINER_multihashmap_put (
+          s->intersected_elements,
+          &elem->key,
+          elem,
+          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+    {
+      /* element with same key encountered twice! */
+      GNUNET_break (0);
+      GNUNET_free (elem);
+      continue;
+    }
+    set_elem.data = &elem->key;
+    set_elem.size = sizeof(elem->key);
+    set_elem.element_type = 0;
+    GNUNET_SETI_add_element (s->intersection_set,
+                             &set_elem,
+                             NULL,
+                             NULL);
+    s->used_element_count++;
+  }
+  GNUNET_SERVICE_client_continue (s->client);
+  if (s->total != s->client_received_element_count)
+  {
+    /* wait for multipart msg */
+    return;
+  }
+  client_request_complete_alice (s);
+}
+
+
+/**
+ * Task run during shutdown.
+ *
+ * @param cls unused
+ */
+static void
+shutdown_task (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down, initiating cleanup.\n");
+  // FIXME: we have to cut our connections to CADET first!
+  if (NULL != my_cadet)
+  {
+    GNUNET_CADET_disconnect (my_cadet);
+    my_cadet = NULL;
+  }
+}
+
+
+/**
+ * A client connected.
+ *
+ * Setup the associated data structure.
+ *
+ * @param cls closure, NULL
+ * @param client identification of the client
+ * @param mq message queue to communicate with @a client
+ * @return our `struct AliceServiceSession`
+ */
+static void *
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *client,
+                   struct GNUNET_MQ_Handle *mq)
+{
+  struct AliceServiceSession *s;
+
+  s = GNUNET_new (struct AliceServiceSession);
+  s->client = client;
+  s->client_mq = mq;
+  return s;
+}
+
+
+/**
+ * A client disconnected.
+ *
+ * Remove the associated session(s), release data structures
+ * and cancel pending outgoing transmissions to the client.
+ *
+ * @param cls closure, NULL
+ * @param client identification of the client
+ * @param app_cls our `struct AliceServiceSession`
+ */
+static void
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *app_cls)
+{
+  struct AliceServiceSession *s = app_cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Client %p disconnected from us.\n",
+              client);
+  s->client = NULL;
+  s->client_mq = NULL;
+  destroy_service_session (s);
+}
+
+
+/**
+ * Initialization of the program and message handlers
+ *
+ * @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)
+{
+  cfg = c;
+  /*
+     offset has to be sufficiently small to allow computation of:
+     m1+m2 mod n == (S + a) + (S + b) mod n,
+     if we have more complex operations, this factor needs to be lowered */
+  my_offset = gcry_mpi_new (GNUNET_CRYPTO_PAILLIER_BITS / 3);
+  gcry_mpi_set_bit (my_offset, GNUNET_CRYPTO_PAILLIER_BITS / 3);
+  GNUNET_CRYPTO_paillier_create (&my_pubkey, &my_privkey);
+  my_cadet = GNUNET_CADET_connect (cfg);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
+  if (NULL == my_cadet)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Connect to CADET failed\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+}
+
+
+/**
+ * Define "main" method using service macro.
+ */
+GNUNET_SERVICE_MAIN (
+  "scalarproduct-alice",
+  GNUNET_SERVICE_OPTION_NONE,
+  &run,
+  &client_connect_cb,
+  &client_disconnect_cb,
+  NULL,
+  GNUNET_MQ_hd_var_size (alice_client_message,
+                         GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE,
+                         struct AliceComputationMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (
+    alice_client_message_multipart,
+    GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_ALICE,
+    struct ComputationBobCryptodataMultipartMessage,
+    NULL),
+  GNUNET_MQ_handler_end ());
+
+
+/* end of gnunet-service-scalarproduct_alice.c */
diff --git a/src/contrib/service/scalarproduct/gnunet-service-scalarproduct_bob.c b/src/contrib/service/scalarproduct/gnunet-service-scalarproduct_bob.c
new file mode 100644
index 000000000..65e732675
--- /dev/null
+++ b/src/contrib/service/scalarproduct/gnunet-service-scalarproduct_bob.c
@@ -0,0 +1,1384 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013, 2014, 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 scalarproduct/gnunet-service-scalarproduct_bob.c
+ * @brief scalarproduct service implementation
+ * @author Christian M. Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include <limits.h>
+#include <gcrypt.h>
+#include "gnunet_util_lib.h"
+#include "gnunet_core_service.h"
+#include "gnunet_cadet_service.h"
+#include "gnunet_applications.h"
+#include "gnunet_protocols.h"
+#include "gnunet_scalarproduct_service.h"
+#include "gnunet_seti_service.h"
+#include "scalarproduct.h"
+#include "gnunet-service-scalarproduct.h"
+#include "gnunet_constants.h"
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "scalarproduct-bob", __VA_ARGS__)
+
+
+/**
+ * An encrypted element key-value pair.
+ */
+struct MpiElement
+{
+  /**
+   * Key used to identify matching pairs of values to multiply.
+   * Points into an existing data structure, to avoid copying
+   * and doubling memory use.
+   */
+  const struct GNUNET_HashCode *key;
+
+  /**
+   * Value represented (a).
+   */
+  gcry_mpi_t value;
+};
+
+
+/**
+ * A scalarproduct session which tracks an offer for a
+ * multiplication service by a local client.
+ */
+struct BobServiceSession
+{
+  /**
+   * (hopefully) unique transaction ID
+   */
+  struct GNUNET_HashCode session_id;
+
+  /**
+   * The client this request is related to.
+   */
+  struct GNUNET_SERVICE_Client *client;
+
+  /**
+   * Client message queue.
+   */
+  struct GNUNET_MQ_Handle *client_mq;
+
+  /**
+   * All non-0-value'd elements transmitted to us.
+   */
+  struct GNUNET_CONTAINER_MultiHashMap *intersected_elements;
+
+  /**
+   * Set of elements for which we will be conducting an intersection.
+   * The resulting elements are then used for computing the scalar product.
+   */
+  struct GNUNET_SETI_Handle *intersection_set;
+
+  /**
+   * Set of elements for which will conduction an intersection.
+   * the resulting elements are then used for computing the scalar product.
+   */
+  struct GNUNET_SETI_OperationHandle *intersection_op;
+
+  /**
+   * CADET port we are listening on.
+   */
+  struct GNUNET_CADET_Port *port;
+
+  /**
+   * a(Alice)
+   */
+  struct MpiElement *sorted_elements;
+
+  /**
+   * E(ai)(Bob) after applying the mask
+   */
+  struct GNUNET_CRYPTO_PaillierCiphertext *e_a;
+
+  /**
+   * Bob's permutation p of R
+   */
+  struct GNUNET_CRYPTO_PaillierCiphertext *r;
+
+  /**
+   * Bob's permutation q of R
+   */
+  struct GNUNET_CRYPTO_PaillierCiphertext *r_prime;
+
+  /**
+   * Bob's "s"
+   */
+  struct GNUNET_CRYPTO_PaillierCiphertext s;
+
+  /**
+   * Bob's "s'"
+   */
+  struct GNUNET_CRYPTO_PaillierCiphertext s_prime;
+
+  /**
+   * Handle for our associated incoming CADET session, or NULL
+   * if we have not gotten one yet.
+   */
+  struct CadetIncomingSession *cadet;
+
+  /**
+   * How many elements will be supplied in total from the client.
+   */
+  uint32_t total;
+
+  /**
+   * Already transferred elements (received) for multipart
+   * messages from client. Always less than @e total.
+   */
+  uint32_t client_received_element_count;
+
+  /**
+   * How many elements actually are used for the scalar product.
+   * Size of the arrays in @e r and @e r_prime.  Also sometimes
+   * used as an index into the arrays during construction.
+   */
+  uint32_t used_element_count;
+
+  /**
+   * Counts the number of values received from Alice by us.
+   * Always less than @e used_element_count.
+   */
+  uint32_t cadet_received_element_count;
+
+  /**
+   * Counts the number of values transmitted from us to Alice.
+   * Always less than @e used_element_count.
+   */
+  uint32_t cadet_transmitted_element_count;
+
+  /**
+   * State of this session.   In
+   * #GNUNET_SCALARPRODUCT_STATUS_ACTIVE while operation is
+   * ongoing, afterwards in #GNUNET_SCALARPRODUCT_STATUS_SUCCESS or
+   * #GNUNET_SCALARPRODUCT_STATUS_FAILURE.
+   */
+  enum GNUNET_SCALARPRODUCT_ResponseStatus status;
+
+  /**
+   * Are we already in #destroy_service_session()?
+   */
+  int in_destroy;
+
+  /**
+   * The CADET channel.
+   */
+  struct GNUNET_CADET_Channel *channel;
+
+  /**
+   * Originator's peer identity. (Only for diagnostics.)
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /**
+   * Public key of the remote service.
+   */
+  struct GNUNET_CRYPTO_PaillierPublicKey remote_pubkey;
+
+  /**
+   * The message queue for this channel.
+   */
+  struct GNUNET_MQ_Handle *cadet_mq;
+};
+
+
+/**
+ * GNUnet configuration handle
+ */
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Service's own public key
+ */
+static struct GNUNET_CRYPTO_PaillierPublicKey my_pubkey;
+
+/**
+ * Service's own private key
+ */
+static struct GNUNET_CRYPTO_PaillierPrivateKey my_privkey;
+
+/**
+ * Service's offset for values that could possibly be negative but are plaintext for encryption.
+ */
+static gcry_mpi_t my_offset;
+
+/**
+ * Handle to the CADET service.
+ */
+static struct GNUNET_CADET_Handle *my_cadet;
+
+
+/**
+ * Callback used to free the elements in the map.
+ *
+ * @param cls NULL
+ * @param key key of the element
+ * @param value the value to free
+ */
+static int
+free_element_cb (void *cls,
+                 const struct GNUNET_HashCode *key,
+                 void *value)
+{
+  struct GNUNET_SCALARPRODUCT_Element *element = value;
+
+  GNUNET_free (element);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Destroy session state, we are done with it.
+ *
+ * @param session the session to free elements from
+ */
+static void
+destroy_service_session (struct BobServiceSession *s)
+{
+  unsigned int i;
+
+  if (GNUNET_YES == s->in_destroy)
+    return;
+  s->in_destroy = GNUNET_YES;
+  if (NULL != s->client)
+  {
+    struct GNUNET_SERVICE_Client *c = s->client;
+
+    s->client = NULL;
+    GNUNET_SERVICE_client_drop (c);
+  }
+  if (NULL != s->intersected_elements)
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (s->intersected_elements,
+                                           &free_element_cb,
+                                           NULL);
+    GNUNET_CONTAINER_multihashmap_destroy (s->intersected_elements);
+    s->intersected_elements = NULL;
+  }
+  if (NULL != s->intersection_op)
+  {
+    GNUNET_SETI_operation_cancel (s->intersection_op);
+    s->intersection_op = NULL;
+  }
+  if (NULL != s->intersection_set)
+  {
+    GNUNET_SETI_destroy (s->intersection_set);
+    s->intersection_set = NULL;
+  }
+  if (NULL != s->e_a)
+  {
+    GNUNET_free (s->e_a);
+    s->e_a = NULL;
+  }
+  if (NULL != s->sorted_elements)
+  {
+    for (i = 0; i < s->used_element_count; i++)
+      gcry_mpi_release (s->sorted_elements[i].value);
+    GNUNET_free (s->sorted_elements);
+    s->sorted_elements = NULL;
+  }
+  if (NULL != s->r)
+  {
+    GNUNET_free (s->r);
+    s->r = NULL;
+  }
+  if (NULL != s->r_prime)
+  {
+    GNUNET_free (s->r_prime);
+    s->r_prime = NULL;
+  }
+  if (NULL != s->port)
+  {
+    GNUNET_CADET_close_port (s->port);
+    s->port = NULL;
+  }
+  if (NULL != s->channel)
+  {
+    GNUNET_CADET_channel_destroy (s->channel);
+    s->channel = NULL;
+  }
+  GNUNET_free (s);
+}
+
+
+/**
+ * Notify the client that the session has succeeded or failed.  This
+ * message gets sent to Bob's client if the operation completed or
+ * Alice disconnected.
+ *
+ * @param session the associated client session to fail or succeed
+ */
+static void
+prepare_client_end_notification (struct BobServiceSession *session)
+{
+  struct ClientResponseMessage *msg;
+  struct GNUNET_MQ_Envelope *e;
+
+  if (NULL == session->client_mq)
+    return; /* no client left to be notified */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending session-end notification with status %d to client for session %s\n",
+              session->status,
+              GNUNET_h2s (&session->session_id));
+  e = GNUNET_MQ_msg (msg,
+                     GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT);
+  msg->range = 0;
+  msg->product_length = htonl (0);
+  msg->status = htonl (session->status);
+  GNUNET_MQ_send (session->client_mq,
+                  e);
+}
+
+
+/**
+ * Function called whenever a channel is destroyed.  Should clean up
+ * any associated state.
+ *
+ * It must NOT call #GNUNET_CADET_channel_destroy() on the channel.
+ *
+ * @param cls the `struct BobServiceSession`
+ * @param channel connection to the other end (henceforth invalid)
+ */
+static void
+cb_channel_destruction (void *cls,
+                        const struct GNUNET_CADET_Channel *channel)
+{
+  struct BobServiceSession *s = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Peer disconnected, terminating session %s with peer %s\n",
+              GNUNET_h2s (&s->session_id),
+              GNUNET_i2s (&s->peer));
+  if (GNUNET_SCALARPRODUCT_STATUS_ACTIVE == s->status)
+  {
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    prepare_client_end_notification (s);
+  }
+  s->channel = NULL;
+  destroy_service_session (s);
+}
+
+
+/**
+ * MQ finished giving our last message to CADET, now notify
+ * the client that we are finished.
+ */
+static void
+bob_cadet_done_cb (void *cls)
+{
+  struct BobServiceSession *session = cls;
+
+  session->status = GNUNET_SCALARPRODUCT_STATUS_SUCCESS;
+  prepare_client_end_notification (session);
+}
+
+
+/**
+ * Maximum count of elements we can put into a multipart message
+ */
+#define ELEMENT_CAPACITY ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 \
+                           - sizeof(struct BobCryptodataMultipartMessage)) \
+                          / sizeof(struct \
+                                   GNUNET_CRYPTO_PaillierCiphertext))
+
+
+/**
+ * Send a multipart chunk of a service response from Bob to Alice.
+ * This element only contains the two permutations of R, R'.
+ *
+ * @param s the associated service session
+ */
+static void
+transmit_bobs_cryptodata_message_multipart (struct BobServiceSession *s)
+{
+  struct GNUNET_CRYPTO_PaillierCiphertext *payload;
+  struct BobCryptodataMultipartMessage *msg;
+  struct GNUNET_MQ_Envelope *e;
+  unsigned int i;
+  unsigned int j;
+  uint32_t todo_count;
+
+  while (s->cadet_transmitted_element_count != s->used_element_count)
+  {
+    todo_count = s->used_element_count - s->cadet_transmitted_element_count;
+    if (todo_count > ELEMENT_CAPACITY / 2)
+      todo_count = ELEMENT_CAPACITY / 2;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending %u additional crypto values to Alice\n",
+                (unsigned int) todo_count);
+    e = GNUNET_MQ_msg_extra (msg,
+                             todo_count * sizeof(struct
+                                                 GNUNET_CRYPTO_PaillierCiphertext)
+                             * 2,
+                             GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA_MULTIPART);
+    msg->contained_element_count = htonl (todo_count);
+    payload = (struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
+    for (i = s->cadet_transmitted_element_count, j = 0; i <
+         s->cadet_transmitted_element_count + todo_count; i++)
+    {
+      // r[i][p] and r[i][q]
+      GNUNET_memcpy (&payload[j++],
+                     &s->r[i],
+                     sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
+      GNUNET_memcpy (&payload[j++],
+                     &s->r_prime[i],
+                     sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
+    }
+    s->cadet_transmitted_element_count += todo_count;
+    if (s->cadet_transmitted_element_count == s->used_element_count)
+      GNUNET_MQ_notify_sent (e,
+                             &bob_cadet_done_cb,
+                             s);
+    GNUNET_MQ_send (s->cadet_mq,
+                    e);
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "All values queued for Alice, Bob is done\n");
+}
+
+
+/**
+ * Bob generates the response message to be sent to Alice after
+ * computing the values (1), (2), S and S'.
+ *
+ *  (1)[]: $E_A(a_{pi(i)}) times E_A(- r_{pi(i)} - b_{pi(i)}) &= E_A(a_{pi(i)} - r_{pi(i)} - b_{pi(i)})$
+ *  (2)[]: $E_A(a_{pi'(i)}) times E_A(- r_{pi'(i)}) &= E_A(a_{pi'(i)} - r_{pi'(i)})$
+ *      S: $S := E_A(sum (r_i + b_i)^2)$
+ *     S': $S' := E_A(sum r_i^2)$
+ *
+ * @param s the associated requesting session with Alice
+ */
+static void
+transmit_bobs_cryptodata_message (struct BobServiceSession *s)
+{
+  struct BobCryptodataMessage *msg;
+  struct GNUNET_MQ_Envelope *e;
+  struct GNUNET_CRYPTO_PaillierCiphertext *payload;
+  unsigned int i;
+
+  s->cadet_transmitted_element_count
+    = ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 - sizeof(struct
+                                                             BobCryptodataMessage))
+       / sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) / 2) - 1;
+  if (s->cadet_transmitted_element_count > s->used_element_count)
+    s->cadet_transmitted_element_count = s->used_element_count;
+
+  e = GNUNET_MQ_msg_extra (msg,
+                           (2 + s->cadet_transmitted_element_count * 2)
+                           * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext),
+                           GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA);
+  msg->contained_element_count = htonl (s->cadet_transmitted_element_count);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending %u/%u crypto values to Alice\n",
+              (unsigned int) s->cadet_transmitted_element_count,
+              (unsigned int) s->used_element_count);
+
+  payload = (struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
+  GNUNET_memcpy (&payload[0],
+                 &s->s,
+                 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
+  GNUNET_memcpy (&payload[1],
+                 &s->s_prime,
+                 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
+
+  payload = &payload[2];
+  // convert k[][]
+  for (i = 0; i < s->cadet_transmitted_element_count; i++)
+  {
+    // k[i][p] and k[i][q]
+    GNUNET_memcpy (&payload[i * 2],
+                   &s->r[i],
+                   sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
+    GNUNET_memcpy (&payload[i * 2 + 1],
+                   &s->r_prime[i],
+                   sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
+  }
+  if (s->cadet_transmitted_element_count == s->used_element_count)
+    GNUNET_MQ_notify_sent (e,
+                           &bob_cadet_done_cb,
+                           s);
+  GNUNET_MQ_send (s->cadet_mq,
+                  e);
+  transmit_bobs_cryptodata_message_multipart (s);
+}
+
+
+#undef ELEMENT_CAPACITY
+
+
+/**
+ * Computes the square sum over a vector of a given length.
+ *
+ * @param vector the vector to compute over
+ * @param length the length of the vector
+ * @return an MPI value containing the calculated sum, never NULL
+ * TODO: code duplication with Alice!
+ */
+static gcry_mpi_t
+compute_square_sum (const gcry_mpi_t *vector,
+                    uint32_t length)
+{
+  gcry_mpi_t elem;
+  gcry_mpi_t sum;
+  uint32_t i;
+
+  GNUNET_assert (NULL != (sum = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (elem = gcry_mpi_new (0)));
+  for (i = 0; i < length; i++)
+  {
+    gcry_mpi_mul (elem, vector[i], vector[i]);
+    gcry_mpi_add (sum, sum, elem);
+  }
+  gcry_mpi_release (elem);
+  return sum;
+}
+
+
+/**
+ * Compute the values
+ *  (1)[]: $E_A(a_{pi(i)}) otimes E_A(- r_{pi(i)} - b_{pi(i)}) &= E_A(a_{pi(i)} - r_{pi(i)} - b_{pi(i)})$
+ *  (2)[]: $E_A(a_{pi'(i)}) otimes E_A(- r_{pi'(i)}) &= E_A(a_{pi'(i)} - r_{pi'(i)})$
+ *      S: $S := E_A(sum (r_i + b_i)^2)$
+ *     S': $S' := E_A(sum r_i^2)$
+ *
+ * @param session the requesting session + bob's requesting peer
+ * @return #GNUNET_OK on success
+ */
+static int
+compute_service_response (struct BobServiceSession *session)
+{
+  uint32_t i;
+  unsigned int *p;
+  unsigned int *q;
+  uint32_t count;
+  gcry_mpi_t *rand;
+  gcry_mpi_t tmp;
+  const struct MpiElement *b;
+  struct GNUNET_CRYPTO_PaillierCiphertext *a;
+  struct GNUNET_CRYPTO_PaillierCiphertext *r;
+  struct GNUNET_CRYPTO_PaillierCiphertext *r_prime;
+
+  count = session->used_element_count;
+  a = session->e_a;
+  b = session->sorted_elements;
+  q = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_WEAK,
+                                    count);
+  p = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_WEAK,
+                                    count);
+  rand = GNUNET_malloc (sizeof(gcry_mpi_t) * count);
+  for (i = 0; i < count; i++)
+    GNUNET_assert (NULL != (rand[i] = gcry_mpi_new (0)));
+  r = GNUNET_malloc (sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) * count);
+  r_prime = GNUNET_malloc (sizeof(struct GNUNET_CRYPTO_PaillierCiphertext)
+                           * count);
+
+  for (i = 0; i < count; i++)
+  {
+    int32_t svalue;
+
+    svalue = (int32_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                                 UINT32_MAX);
+    // long to gcry_mpi_t
+    if (svalue < 0)
+      gcry_mpi_sub_ui (rand[i],
+                       rand[i],
+                       -svalue);
+    else
+      rand[i] = gcry_mpi_set_ui (rand[i], svalue);
+  }
+
+  tmp = gcry_mpi_new (0);
+  // encrypt the element
+  // for the sake of readability I decided to have dedicated permutation
+  // vectors, which get rid of all the lookups in p/q.
+  // however, ap/aq are not absolutely necessary but are just abstraction
+  // Calculate Kp = E(S + a_pi) (+) E(S - r_pi - b_pi)
+  for (i = 0; i < count; i++)
+  {
+    // E(S - r_pi - b_pi)
+    gcry_mpi_sub (tmp, my_offset, rand[p[i]]);
+    gcry_mpi_sub (tmp, tmp, b[p[i]].value);
+    GNUNET_assert (2 ==
+                   GNUNET_CRYPTO_paillier_encrypt (&session->remote_pubkey,
+                                                   tmp,
+                                                   2,
+                                                   &r[i]));
+
+    // E(S - r_pi - b_pi) * E(S + a_pi) ==  E(2*S + a - r - b)
+    if (GNUNET_OK !=
+        GNUNET_CRYPTO_paillier_hom_add (&session->remote_pubkey,
+                                        &r[i],
+                                        &a[p[i]],
+                                        &r[i]))
+    {
+      GNUNET_break_op (0);
+      goto error_cleanup;
+    }
+  }
+
+  // Calculate Kq = E(S + a_qi) (+) E(S - r_qi)
+  for (i = 0; i < count; i++)
+  {
+    // E(S - r_qi)
+    gcry_mpi_sub (tmp, my_offset, rand[q[i]]);
+    GNUNET_assert (2 ==
+                   GNUNET_CRYPTO_paillier_encrypt (&session->remote_pubkey,
+                                                   tmp,
+                                                   2,
+                                                   &r_prime[i]));
+
+    // E(S - r_qi) * E(S + a_qi) == E(2*S + a_qi - r_qi)
+    if (GNUNET_OK !=
+        GNUNET_CRYPTO_paillier_hom_add (&session->remote_pubkey,
+                                        &r_prime[i],
+                                        &a[q[i]],
+                                        &r_prime[i]))
+    {
+      GNUNET_break_op (0);
+      goto error_cleanup;
+    }
+  }
+  gcry_mpi_release (tmp);
+
+  // Calculate S' =  E(SUM( r_i^2 ))
+  tmp = compute_square_sum (rand, count);
+  GNUNET_assert (1 ==
+                 GNUNET_CRYPTO_paillier_encrypt (&session->remote_pubkey,
+                                                 tmp,
+                                                 1,
+                                                 &session->s_prime));
+  gcry_mpi_release (tmp);
+
+  // Calculate S = E(SUM( (r_i + b_i)^2 ))
+  for (i = 0; i < count; i++)
+    gcry_mpi_add (rand[i], rand[i], b[i].value);
+  tmp = compute_square_sum (rand, count);
+  GNUNET_assert (1 ==
+                 GNUNET_CRYPTO_paillier_encrypt (&session->remote_pubkey,
+                                                 tmp,
+                                                 1,
+                                                 &session->s));
+  gcry_mpi_release (tmp);
+
+  session->r = r;
+  session->r_prime = r_prime;
+
+  for (i = 0; i < count; i++)
+    gcry_mpi_release (rand[i]);
+  GNUNET_free (session->e_a);
+  session->e_a = NULL;
+  GNUNET_free (p);
+  GNUNET_free (q);
+  GNUNET_free (rand);
+  return GNUNET_OK;
+
+error_cleanup:
+  GNUNET_free (r);
+  GNUNET_free (r_prime);
+  gcry_mpi_release (tmp);
+  GNUNET_free (p);
+  GNUNET_free (q);
+  for (i = 0; i < count; i++)
+    gcry_mpi_release (rand[i]);
+  GNUNET_free (rand);
+  return GNUNET_SYSERR;
+}
+
+
+/**
+ * Iterator to copy over messages from the hash map
+ * into an array for sorting.
+ *
+ * @param cls the `struct BobServiceSession *`
+ * @param key the key (unused)
+ * @param value the `struct GNUNET_SCALARPRODUCT_Element *`
+ * TODO: code duplication with Alice!
+ */
+static int
+copy_element_cb (void *cls,
+                 const struct GNUNET_HashCode *key,
+                 void *value)
+{
+  struct BobServiceSession *s = cls;
+  struct GNUNET_SCALARPRODUCT_Element *e = value;
+  gcry_mpi_t mval;
+  int64_t val;
+
+  mval = gcry_mpi_new (0);
+  val = (int64_t) GNUNET_ntohll (e->value);
+  if (0 > val)
+    gcry_mpi_sub_ui (mval, mval, -val);
+  else
+    gcry_mpi_add_ui (mval, mval, val);
+  s->sorted_elements [s->used_element_count].value = mval;
+  s->sorted_elements [s->used_element_count].key = &e->key;
+  s->used_element_count++;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Compare two `struct MpiValue`s by key for sorting.
+ *
+ * @param a pointer to first `struct MpiValue *`
+ * @param b pointer to first `struct MpiValue *`
+ * @return -1 for a < b, 0 for a=b, 1 for a > b.
+ * TODO: code duplication with Alice!
+ */
+static int
+element_cmp (const void *a,
+             const void *b)
+{
+  const struct MpiElement *ma = a;
+  const struct MpiElement *mb = b;
+
+  return GNUNET_CRYPTO_hash_cmp (ma->key,
+                                 mb->key);
+}
+
+
+/**
+ * Intersection operation and receiving data via CADET from
+ * Alice are both done, compute and transmit our reply via
+ * CADET.
+ *
+ * @param s session to transmit reply for.
+ */
+static void
+transmit_cryptographic_reply (struct BobServiceSession *s)
+{
+  struct GNUNET_CADET_Channel *channel;
+
+  /* TODO: code duplication with Alice! */
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received everything, building reply for Alice\n");
+  s->sorted_elements
+    = GNUNET_malloc (GNUNET_CONTAINER_multihashmap_size (
+                       s->intersected_elements)
+                     * sizeof(struct MpiElement));
+  s->used_element_count = 0;
+  GNUNET_CONTAINER_multihashmap_iterate (s->intersected_elements,
+                                         &copy_element_cb,
+                                         s);
+  qsort (s->sorted_elements,
+         s->used_element_count,
+         sizeof(struct MpiElement),
+         &element_cmp);
+  if (GNUNET_OK !=
+      compute_service_response (s))
+  {
+    channel = s->channel;
+    s->channel = NULL;
+    GNUNET_CADET_channel_destroy (channel);
+    return;
+  }
+  transmit_bobs_cryptodata_message (s);
+}
+
+
+/**
+ * Check a multipart-chunk of a request from another service to
+ * calculate a scalarproduct with us.
+ *
+ * @param cls the `struct BobServiceSession *`
+ * @param msg the actual message
+ * @return #GNUNET_OK to keep the connection open,
+ *         #GNUNET_SYSERR to close it (signal serious error)
+ */
+static int
+check_alices_cryptodata_message (void *cls,
+                                 const struct AliceCryptodataMessage *msg)
+{
+  struct BobServiceSession *s = cls;
+  uint32_t contained_elements;
+  size_t msg_length;
+  uint16_t msize;
+  unsigned int max;
+
+  msize = ntohs (msg->header.size);
+  contained_elements = ntohl (msg->contained_element_count);
+  /* Our intersection may still be ongoing, but this is nevertheless
+     an upper bound on the required array size */
+  max = GNUNET_CONTAINER_multihashmap_size (s->intersected_elements);
+  msg_length = sizeof(struct AliceCryptodataMessage)
+               + contained_elements * sizeof(struct
+                                             GNUNET_CRYPTO_PaillierCiphertext);
+  if ((msize != msg_length) ||
+      (0 == contained_elements) ||
+      (contained_elements > UINT16_MAX) ||
+      (max < contained_elements + s->cadet_received_element_count))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle a multipart-chunk of a request from another service to
+ * calculate a scalarproduct with us.
+ *
+ * @param cls the `struct BobServiceSession *`
+ * @param msg the actual message
+ */
+static void
+handle_alices_cryptodata_message (void *cls,
+                                  const struct AliceCryptodataMessage *msg)
+{
+  struct BobServiceSession *s = cls;
+  const struct GNUNET_CRYPTO_PaillierCiphertext *payload;
+  uint32_t contained_elements;
+  unsigned int max;
+
+  contained_elements = ntohl (msg->contained_element_count);
+  /* Our intersection may still be ongoing, but this is nevertheless
+     an upper bound on the required array size */
+  max = GNUNET_CONTAINER_multihashmap_size (s->intersected_elements);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received %u crypto values from Alice\n",
+              (unsigned int) contained_elements);
+
+  payload = (const struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
+  if (NULL == s->e_a)
+    s->e_a = GNUNET_new_array (max,
+                               struct GNUNET_CRYPTO_PaillierCiphertext);
+  GNUNET_memcpy (&s->e_a[s->cadet_received_element_count],
+                 payload,
+                 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext)
+                 * contained_elements);
+  s->cadet_received_element_count += contained_elements;
+
+  if ((s->cadet_received_element_count == max) &&
+      (NULL == s->intersection_op))
+  {
+    /* intersection has finished also on our side, and
+       we got the full set, so we can proceed with the
+       CADET response(s) */
+    transmit_cryptographic_reply (s);
+  }
+  GNUNET_CADET_receive_done (s->channel);
+}
+
+
+/**
+ * Callback for set operation results. Called for each element
+ * that needs to be removed from the result set.
+ *
+ * @param cls closure with the `struct BobServiceSession`
+ * @param element a result element, only valid if status is #GNUNET_SETI_STATUS_OK
+ * @param current_size current set size
+ * @param status what has happened with the set intersection?
+ */
+static void
+cb_intersection_element_removed (void *cls,
+                                 const struct GNUNET_SETI_Element *element,
+                                 uint64_t current_size,
+                                 enum GNUNET_SETI_Status status)
+{
+  struct BobServiceSession *s = cls;
+  struct GNUNET_SCALARPRODUCT_Element *se;
+
+  switch (status)
+  {
+  case GNUNET_SETI_STATUS_DEL_LOCAL:
+    /* this element has been removed from the set */
+    se = GNUNET_CONTAINER_multihashmap_get (s->intersected_elements,
+                                            element->data);
+    GNUNET_assert (NULL != se);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Removed element with key %s and value %lld\n",
+         GNUNET_h2s (&se->key),
+         (long long) GNUNET_ntohll (se->value));
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multihashmap_remove (
+                     s->intersected_elements,
+                     element->data,
+                     se));
+    GNUNET_free (se);
+    return;
+  case GNUNET_SETI_STATUS_DONE:
+    s->intersection_op = NULL;
+    GNUNET_break (NULL == s->intersection_set);
+    GNUNET_CADET_receive_done (s->channel);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Finished intersection, %d items remain\n",
+         GNUNET_CONTAINER_multihashmap_size (s->intersected_elements));
+    if (s->client_received_element_count ==
+        GNUNET_CONTAINER_multihashmap_size (s->intersected_elements))
+    {
+      /* CADET transmission from Alice is also already done,
+         start with our own reply */
+      transmit_cryptographic_reply (s);
+    }
+    return;
+  case GNUNET_SETI_STATUS_FAILURE:
+    /* unhandled status code */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Set intersection failed!\n");
+    s->intersection_op = NULL;
+    if (NULL != s->intersection_set)
+    {
+      GNUNET_SETI_destroy (s->intersection_set);
+      s->intersection_set = NULL;
+    }
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    prepare_client_end_notification (s);
+    return;
+  default:
+    GNUNET_break (0);
+    return;
+  }
+}
+
+
+/**
+ * We've paired up a client session with an incoming CADET request.
+ * Initiate set intersection work.
+ *
+ * @param s client session to start intersection for
+ */
+static void
+start_intersection (struct BobServiceSession *s)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Got session with key %s and %u elements, starting intersection.\n",
+              GNUNET_h2s (&s->session_id),
+              (unsigned int) s->total);
+
+  s->intersection_op
+    = GNUNET_SETI_prepare (&s->peer,
+                           &s->session_id,
+                           NULL,
+                           (struct GNUNET_SETI_Option[]) { { 0 } },
+                           &cb_intersection_element_removed,
+                           s);
+  if (GNUNET_OK !=
+      GNUNET_SETI_commit (s->intersection_op,
+                          s->intersection_set))
+  {
+    GNUNET_break (0);
+    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
+    prepare_client_end_notification (s);
+    return;
+  }
+  GNUNET_SETI_destroy (s->intersection_set);
+  s->intersection_set = NULL;
+}
+
+
+/**
+ * Handle a request from Alice to calculate a scalarproduct with us (Bob).
+ *
+ * @param cls the `struct BobServiceSession *`
+ * @param msg the actual message
+ */
+static void
+handle_alices_computation_request (void *cls,
+                                   const struct ServiceRequestMessage *msg)
+{
+  struct BobServiceSession *s = cls;
+
+  s->session_id = msg->session_id; // ??
+  s->remote_pubkey = msg->public_key;
+  if (s->client_received_element_count == s->total)
+    start_intersection (s);
+}
+
+
+/**
+ * Function called for inbound channels on Bob's end.  Does some
+ * preliminary initialization, more happens after we get Alice's first
+ * message.
+ *
+ * @param cls closure with the `struct BobServiceSession`
+ * @param channel new handle to the channel
+ * @param initiator peer that started the channel
+ * @return session associated with the channel
+ */
+static void *
+cb_channel_incoming (void *cls,
+                     struct GNUNET_CADET_Channel *channel,
+                     const struct GNUNET_PeerIdentity *initiator)
+{
+  struct BobServiceSession *s = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "New incoming channel from peer %s.\n",
+              GNUNET_i2s (initiator));
+  GNUNET_CADET_close_port (s->port);
+  s->port = NULL;
+  s->channel = channel;
+  s->peer = *initiator;
+  s->cadet_mq = GNUNET_CADET_get_mq (s->channel);
+  return s;
+}
+
+
+/**
+ * We're receiving additional set data. Check it is well-formed.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+static int
+check_bob_client_message_multipart (void *cls,
+                                    const struct
+                                    ComputationBobCryptodataMultipartMessage *
+                                    msg)
+{
+  struct BobServiceSession *s = cls;
+  uint32_t contained_count;
+  uint16_t msize;
+
+  msize = ntohs (msg->header.size);
+  contained_count = ntohl (msg->element_count_contained);
+  if ((msize != (sizeof(struct ComputationBobCryptodataMultipartMessage)
+                 + contained_count * sizeof(struct
+                                            GNUNET_SCALARPRODUCT_Element))) ||
+      (0 == contained_count) ||
+      (UINT16_MAX < contained_count) ||
+      (s->total == s->client_received_element_count) ||
+      (s->total < s->client_received_element_count + contained_count))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * We're receiving additional set data. Add it to our
+ * set and if we are done, initiate the transaction.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ */
+static void
+handle_bob_client_message_multipart (void *cls,
+                                     const struct
+                                     ComputationBobCryptodataMultipartMessage *
+                                     msg)
+{
+  struct BobServiceSession *s = cls;
+  uint32_t contained_count;
+  const struct GNUNET_SCALARPRODUCT_Element *elements;
+  struct GNUNET_SETI_Element set_elem;
+  struct GNUNET_SCALARPRODUCT_Element *elem;
+
+  contained_count = ntohl (msg->element_count_contained);
+  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
+  for (uint32_t i = 0; i < contained_count; i++)
+  {
+    elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
+    GNUNET_memcpy (elem,
+                   &elements[i],
+                   sizeof(struct GNUNET_SCALARPRODUCT_Element));
+    if (GNUNET_SYSERR ==
+        GNUNET_CONTAINER_multihashmap_put (s->intersected_elements,
+                                           &elem->key,
+                                           elem,
+                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+    {
+      GNUNET_break (0);
+      GNUNET_free (elem);
+      continue;
+    }
+    set_elem.data = &elem->key;
+    set_elem.size = sizeof(elem->key);
+    set_elem.element_type = 0;
+    GNUNET_SETI_add_element (s->intersection_set,
+                             &set_elem,
+                             NULL, NULL);
+  }
+  s->client_received_element_count += contained_count;
+  GNUNET_SERVICE_client_continue (s->client);
+  if (s->total != s->client_received_element_count)
+  {
+    /* more to come */
+    return;
+  }
+  if (NULL == s->channel)
+  {
+    /* no Alice waiting for this request, wait for Alice */
+    return;
+  }
+  start_intersection (s);
+}
+
+
+/**
+ * Handler for Bob's a client request message.  Check @a msg is
+ * well-formed.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+static int
+check_bob_client_message (void *cls,
+                          const struct BobComputationMessage *msg)
+{
+  struct BobServiceSession *s = cls;
+  uint32_t contained_count;
+  uint32_t total_count;
+  uint16_t msize;
+
+  if (GNUNET_SCALARPRODUCT_STATUS_INIT != s->status)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  msize = ntohs (msg->header.size);
+  total_count = ntohl (msg->element_count_total);
+  contained_count = ntohl (msg->element_count_contained);
+  if ((0 == total_count) ||
+      (0 == contained_count) ||
+      (UINT16_MAX < contained_count) ||
+      (msize != (sizeof(struct BobComputationMessage)
+                 + contained_count * sizeof(struct
+                                            GNUNET_SCALARPRODUCT_Element))))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handler for Bob's a client request message.  Bob is in the response
+ * role, keep the values + session and waiting for a matching session
+ * or process a waiting request from Alice.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ */
+static void
+handle_bob_client_message (void *cls,
+                           const struct BobComputationMessage *msg)
+{
+  struct BobServiceSession *s = cls;
+  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
+    GNUNET_MQ_hd_fixed_size (alices_computation_request,
+                             GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SESSION_INITIALIZATION,
+                             struct ServiceRequestMessage,
+                             NULL),
+    GNUNET_MQ_hd_var_size (alices_cryptodata_message,
+                           GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_CRYPTODATA,
+                           struct AliceCryptodataMessage,
+                           NULL),
+    GNUNET_MQ_handler_end ()
+  };
+  uint32_t contained_count;
+  uint32_t total_count;
+  const struct GNUNET_SCALARPRODUCT_Element *elements;
+  struct GNUNET_SETI_Element set_elem;
+  struct GNUNET_SCALARPRODUCT_Element *elem;
+
+  total_count = ntohl (msg->element_count_total);
+  contained_count = ntohl (msg->element_count_contained);
+
+  s->status = GNUNET_SCALARPRODUCT_STATUS_ACTIVE;
+  s->total = total_count;
+  s->client_received_element_count = contained_count;
+  s->session_id = msg->session_key;
+  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
+  s->intersected_elements
+    = GNUNET_CONTAINER_multihashmap_create (s->total,
+                                            GNUNET_YES);
+  s->intersection_set = GNUNET_SETI_create (cfg);
+  for (uint32_t i = 0; i < contained_count; i++)
+  {
+    if (0 == GNUNET_ntohll (elements[i].value))
+      continue;
+    elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
+    GNUNET_memcpy (elem,
+                   &elements[i],
+                   sizeof(struct GNUNET_SCALARPRODUCT_Element));
+    if (GNUNET_SYSERR ==
+        GNUNET_CONTAINER_multihashmap_put (s->intersected_elements,
+                                           &elem->key,
+                                           elem,
+                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+    {
+      GNUNET_break (0);
+      GNUNET_free (elem);
+      continue;
+    }
+    set_elem.data = &elem->key;
+    set_elem.size = sizeof(elem->key);
+    set_elem.element_type = 0;
+    GNUNET_SETI_add_element (s->intersection_set,
+                             &set_elem,
+                             NULL, NULL);
+    s->used_element_count++;
+  }
+  GNUNET_SERVICE_client_continue (s->client);
+  /* We're ready, open the port */
+  s->port = GNUNET_CADET_open_port (my_cadet,
+                                    &msg->session_key,
+                                    &cb_channel_incoming,
+                                    s,
+                                    NULL,
+                                    &cb_channel_destruction,
+                                    cadet_handlers);
+  if (NULL == s->port)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (s->client);
+    return;
+  }
+}
+
+
+/**
+ * Task run during shutdown.
+ *
+ * @param cls unused
+ */
+static void
+shutdown_task (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Shutting down, initiating cleanup.\n");
+  // FIXME: we have to cut our connections to CADET first!
+  if (NULL != my_cadet)
+  {
+    GNUNET_CADET_disconnect (my_cadet);
+    my_cadet = NULL;
+  }
+}
+
+
+/**
+ * A client connected.
+ *
+ * Setup the associated data structure.
+ *
+ * @param cls closure, NULL
+ * @param client identification of the client
+ * @param mq message queue to communicate with @a client
+ * @return our `struct BobServiceSession`
+ */
+static void *
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *client,
+                   struct GNUNET_MQ_Handle *mq)
+{
+  struct BobServiceSession *s;
+
+  s = GNUNET_new (struct BobServiceSession);
+  s->client = client;
+  s->client_mq = mq;
+  return s;
+}
+
+
+/**
+ * A client disconnected.
+ *
+ * Remove the associated session(s), release data structures
+ * and cancel pending outgoing transmissions to the client.
+ *
+ * @param cls closure, NULL
+ * @param client identification of the client
+ * @param app_cls our `struct BobServiceSession`
+ */
+static void
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *app_cls)
+{
+  struct BobServiceSession *s = app_cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Client disconnected from us.\n");
+  s->client = NULL;
+  destroy_service_session (s);
+}
+
+
+/**
+ * Initialization of the program and message handlers
+ *
+ * @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)
+{
+  cfg = c;
+  /*
+     offset has to be sufficiently small to allow computation of:
+     m1+m2 mod n == (S + a) + (S + b) mod n,
+     if we have more complex operations, this factor needs to be lowered */
+  my_offset = gcry_mpi_new (GNUNET_CRYPTO_PAILLIER_BITS / 3);
+  gcry_mpi_set_bit (my_offset,
+                    GNUNET_CRYPTO_PAILLIER_BITS / 3);
+
+  GNUNET_CRYPTO_paillier_create (&my_pubkey,
+                                 &my_privkey);
+  my_cadet = GNUNET_CADET_connect (cfg);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
+                                 NULL);
+  if (NULL == my_cadet)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Connect to CADET failed\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+}
+
+
+/**
+ * Define "main" method using service macro.
+ */
+GNUNET_SERVICE_MAIN
+  ("scalarproduct-bob",
+  GNUNET_SERVICE_OPTION_NONE,
+  &run,
+  &client_connect_cb,
+  &client_disconnect_cb,
+  NULL,
+  GNUNET_MQ_hd_var_size (bob_client_message,
+                         GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB,
+                         struct BobComputationMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (bob_client_message_multipart,
+                         GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_BOB,
+                         struct ComputationBobCryptodataMultipartMessage,
+                         NULL),
+  GNUNET_MQ_handler_end ());
+
+
+/* end of gnunet-service-scalarproduct_bob.c */
diff --git a/src/contrib/service/scalarproduct/meson.build b/src/contrib/service/scalarproduct/meson.build
new file mode 100644
index 000000000..a3d24cfa9
--- /dev/null
+++ b/src/contrib/service/scalarproduct/meson.build
@@ -0,0 +1,101 @@
+libgnunetscalarproduct_src = ['scalarproduct_api.c']
+
+gnunetservicescalarproducta_src = ['gnunet-service-scalarproduct_alice.c']
+gnunetservicescalarproductb_src = ['gnunet-service-scalarproduct_bob.c']
+gnunetservicescalarproductecca_src = ['gnunet-service-scalarproduct-ecc_alice.c']
+gnunetservicescalarproducteccb_src = ['gnunet-service-scalarproduct-ecc_bob.c']
+
+configure_file(input : 'scalarproduct.conf.in',
+               output : 'scalarproduct.conf',
+               configuration : cdata,
+               install: true,
+               install_dir: pkgcfgdir)
+
+
+if get_option('monolith')
+  foreach p : libgnunetscalarproduct_src + gnunetservicescalarproducta_src + gnunetservicescalarproductb_src + gnunetservicescalarproductecca_src + gnunetservicescalarproducteccb_src
+    gnunet_src += 'scalarproduct/' + p
+  endforeach
+endif
+
+libgnunetscalarproduct = library('gnunetscalarproduct',
+        libgnunetscalarproduct_src,
+        soversion: '0',
+        version: '0.0.0',
+        dependencies: [libgnunetutil_dep,
+                       gcrypt_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir'))
+pkg.generate(libgnunetscalarproduct, url: 'https://www.gnunet.org',
+             description : 'Provides API for accessing the scalarproduct service')
+libgnunetscalarproduct_dep = declare_dependency(link_with : libgnunetscalarproduct)
+
+executable ('gnunet-scalarproduct',
+            ['gnunet-scalarproduct.c'],
+            dependencies: [libgnunetscalarproduct_dep,
+                           libgnunetutil_dep,
+                           gcrypt_dep,
+                           libgnunetstatistics_dep,
+                           libgnunetcore_dep,
+                           libgnunetcadet_dep,
+                           libgnunetblock_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('bindir'))
+
+executable ('gnunet-service-scalarproduct-alice',
+            gnunetservicescalarproducta_src,
+            dependencies: [libgnunetscalarproduct_dep,
+                           libgnunetutil_dep,
+                           gcrypt_dep,
+                           libgnunetseti_dep,
+                           libgnunetstatistics_dep,
+                           libgnunetcore_dep,
+                           libgnunetcadet_dep,
+                           libgnunetblock_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+executable ('gnunet-service-scalarproduct-bob',
+            gnunetservicescalarproductb_src,
+            dependencies: [libgnunetscalarproduct_dep,
+                           libgnunetutil_dep,
+                           gcrypt_dep,
+                           libgnunetseti_dep,
+                           libgnunetstatistics_dep,
+                           libgnunetcore_dep,
+                           libgnunetcadet_dep,
+                           libgnunetblock_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+executable ('gnunet-service-scalarproduct-ecc-alice',
+            gnunetservicescalarproductecca_src,
+            dependencies: [libgnunetscalarproduct_dep,
+                           libgnunetutil_dep,
+                           libgnunetstatistics_dep,
+                           libgnunetcore_dep,
+                           gcrypt_dep,
+                           sodium_dep,
+                           libgnunetseti_dep,
+                           libgnunetcadet_dep,
+                           libgnunetblock_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+executable ('gnunet-service-scalarproduct-ecc-bob',
+            gnunetservicescalarproducteccb_src,
+            dependencies: [libgnunetscalarproduct_dep,
+                           libgnunetutil_dep,
+                           libgnunetstatistics_dep,
+                           libgnunetcore_dep,
+                           gcrypt_dep,
+                           sodium_dep,
+                           libgnunetseti_dep,
+                           libgnunetcadet_dep,
+                           libgnunetblock_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+
diff --git a/src/contrib/service/scalarproduct/perf_scalarproduct.sh b/src/contrib/service/scalarproduct/perf_scalarproduct.sh
new file mode 100755
index 000000000..b15465c9a
--- /dev/null
+++ b/src/contrib/service/scalarproduct/perf_scalarproduct.sh
@@ -0,0 +1,73 @@
+#!/bin/bash
+# Computes a simple scalar product, with configurable vector size.
+#
+# Some results (wall-clock for Alice+Bob, single-core, i7, libgcrypt):
+# SIZE   2048-H(s)  2048-O(s)    1024-O(s)      ECC-2^20-H(s)  ECC-2^28-H(s)
+#  25     10          14            3              2               29
+#  50     17          21            5              2               29
+# 100     32          39            7              2               29
+# 200                 77           13              3               30
+# 400                149           23             OOR              31
+# 800                304           32             OOR              33
+
+# Bandwidth (including set intersection):
+#              RSA-1024       RSA-2048       ECC
+# 800:           629 kb        1234 kb       65 kb
+#
+# LIBSODIUM, AMD Threadripper 1950:
+#
+# SIZE              2048-O(s)    1024-O(s)      ECC-2^20-H(s)  ECC-2^28-H(s)
+#  25                 4.3          0.7             0.129          4.233
+#  50                 7.7          1.2             0.143          4.267
+# 100                10.3          2.4             0.163          4.282
+# 200                19.8          3.0             0.192          4.326
+# 400                35.9          6.0             0.253          4.358
+# 800                73.7         12.6             0.379          4.533
+
+#
+#
+# Configure benchmark size:
+SIZE=800
+#
+# Construct input vectors:
+INPUTALICE="-k CCC -e '"
+INPUTBOB="-k CCC -e '"
+for X in `seq 1 $SIZE`
+do
+  INPUTALICE="${INPUTALICE}A${X},$X;"
+  INPUTBOB="${INPUTBOB}A${X},$X;"
+done
+INPUTALICE="${INPUTALICE}BC,-20000;RO,1000;FL,100;LOL,24;'"
+INPUTBOB="${INPUTBOB}AB,10;RO,3;FL,3;LOL,-1;'"
+
+# necessary to make the testing prefix deterministic, so we can access the config files
+PREFIX=/tmp/test-scalarproduct`date +%H%M%S`
+
+# where can we find the peers config files?
+CFGALICE="-c $PREFIX/0/config"
+CFGBOB="-c $PREFIX/1/config"
+
+# launch two peers in line topology non-interactively
+#
+# interactive mode would terminate the test immediately
+# because the rest of the script is already in stdin,
+# thus redirecting stdin does not suffice)
+#GNUNET_FORCE_LOG=';;;;ERROR'
+#GNUNET_FORCE_LOG='scalarproduct*;;;;DEBUG/cadet-api*;;;;DEBUG'
+GNUNET_TESTING_PREFIX=$PREFIX ../testbed/gnunet-testbed-profiler -n -c test_scalarproduct.conf -p 2 &
+PID=$!
+# sleep 1 is too short on most systems, 2 works on most, 5 seems to be safe
+echo "Waiting for peers to start..."
+sleep 5
+# get Bob's peer ID, necessary for Alice
+PEERIDBOB=`gnunet-peerinfo -qs $CFGBOB`
+
+echo "Running problem of size $SIZE"
+gnunet-scalarproduct $CFGBOB $INPUTBOB &
+time RESULT=`gnunet-scalarproduct $CFGALICE $INPUTALICE -p $PEERIDBOB`
+gnunet-statistics $CFGALICE -s core | grep "bytes encrypted"
+gnunet-statistics $CFGBOB -s core | grep "bytes encrypted"
+
+echo "Terminating testbed..."
+# terminate the testbed
+kill $PID
diff --git a/src/contrib/service/scalarproduct/scalarproduct.conf.in b/src/contrib/service/scalarproduct/scalarproduct.conf.in
new file mode 100644
index 000000000..e2286b076
--- /dev/null
+++ b/src/contrib/service/scalarproduct/scalarproduct.conf.in
@@ -0,0 +1,27 @@
+[scalarproduct-alice]
+START_ON_DEMAND = @START_ON_DEMAND@
+BINARY = gnunet-service-scalarproduct-ecc-alice
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-scalarproduct-alice.sock
+@UNIXONLY@ PORT = 2117
+#ACCEPT_FROM = 127.0.0.1;
+#ACCEPT_FROM6 = ::1;
+UNIX_MATCH_UID = NO
+UNIX_MATCH_GID = YES
+#OPTIONS = -L DEBUG
+#PREFIX = valgrind
+
+
+[scalarproduct-bob]
+START_ON_DEMAND = @START_ON_DEMAND@
+HOSTNAME = localhost
+BINARY = gnunet-service-scalarproduct-ecc-bob
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-scalarproduct-bob.sock
+@UNIXONLY@ PORT = 2118
+
+#ACCEPT_FROM = 127.0.0.1;
+#ACCEPT_FROM6 = ::1;
+UNIX_MATCH_UID = NO
+UNIX_MATCH_GID = YES
+#OPTIONS = -L DEBUG
+
+#PREFIX = valgrind
diff --git a/src/contrib/service/scalarproduct/scalarproduct.h b/src/contrib/service/scalarproduct/scalarproduct.h
new file mode 100644
index 000000000..f2311cda0
--- /dev/null
+++ b/src/contrib/service/scalarproduct/scalarproduct.h
@@ -0,0 +1,177 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009, 2010, 2011, 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   scalarproduct.h
+ * @brief  Scalar Product API Message Types
+ * @author Christian M. Fuchs
+ */
+#ifndef SCALARPRODUCT_H
+#define SCALARPRODUCT_H
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * Log an error message at log-level 'level' that indicates
+ * a failure of the command 'cmd' with the message given
+ * by gcry_strerror(rc).
+ */
+#define LOG_GCRY(level, cmd, rc) do { LOG (level, _ ( \
+                                             "`%s' failed at %s:%d with error: %s\n"), \
+                                           cmd, __FILE__, __LINE__, \
+                                           gcry_strerror (rc)); } while (0)
+
+
+/**
+ * Message type passed from client to service
+ * to initiate a request or responder role
+ */
+struct AliceComputationMessage
+{
+  /**
+   * GNUNET message header with type
+   * #GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * how many elements the vector in payload contains
+   */
+  uint32_t element_count_total GNUNET_PACKED;
+
+  /**
+   * contained elements the vector in payload contains
+   */
+  uint32_t element_count_contained GNUNET_PACKED;
+
+  /**
+   * Always zero.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * the transaction/session key used to identify a session
+   */
+  struct GNUNET_HashCode session_key;
+
+  /**
+   * the identity of a remote peer we want to communicate with
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /**
+   * followed by struct GNUNET_SCALARPRODUCT_Element[]
+   */
+};
+
+
+/**
+ * Message type passed from client to service
+ * to initiate a request or responder role
+ */
+struct BobComputationMessage
+{
+  /**
+   * GNUNET message header with type
+   * #GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * how many elements the vector in payload contains
+   */
+  uint32_t element_count_total GNUNET_PACKED;
+
+  /**
+   * contained elements the vector in payload contains
+   */
+  uint32_t element_count_contained GNUNET_PACKED;
+
+  /**
+   * Always zero.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * the transaction/session key used to identify a session
+   */
+  struct GNUNET_HashCode session_key;
+
+  /**
+   * followed by struct GNUNET_SCALARPRODUCT_Element[]
+   */
+};
+
+
+/**
+ * multipart messages following `struct ComputationMessage`
+ */
+struct ComputationBobCryptodataMultipartMessage
+{
+  /**
+   * GNUNET message header
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * contained elements the vector in payload contains
+   */
+  uint32_t element_count_contained GNUNET_PACKED;
+
+  /**
+   * followed by struct GNUNET_SCALARPRODUCT_Element[]
+   */
+};
+
+
+/**
+ * Message type passed from service client
+ * to finalize a session as requester or responder
+ */
+struct ClientResponseMessage
+{
+  /**
+   * GNUNET message header
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * 0 if no product attached
+   */
+  uint32_t product_length GNUNET_PACKED;
+
+  /**
+   * Status information about the outcome of this session,
+   * An `enum GNUNET_SCALARPRODUCT_ResponseStatus` (in NBO).
+   */
+  uint32_t status GNUNET_PACKED;
+
+  /**
+   * Workaround for libgcrypt: -1 if negative, 0 if zero, else 1
+   */
+  int32_t range GNUNET_PACKED;
+
+  /**
+   * followed by product of length product_length (or nothing)
+   */
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+#endif  /* SCALARPRODUCT_H */
diff --git a/src/contrib/service/scalarproduct/scalarproduct_api.c b/src/contrib/service/scalarproduct/scalarproduct_api.c
new file mode 100644
index 000000000..8c667a72e
--- /dev/null
+++ b/src/contrib/service/scalarproduct/scalarproduct_api.c
@@ -0,0 +1,468 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013, 2014, 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 scalarproduct/scalarproduct_api.c
+ * @brief API for the scalarproduct
+ * @author Christian Fuchs
+ * @author Gaurav Kukreja
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_statistics_service.h"
+#include "gnunet_scalarproduct_service.h"
+#include "gnunet_protocols.h"
+#include "scalarproduct.h"
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "scalarproduct-api", __VA_ARGS__)
+
+
+/**
+ * The abstraction function for our internal callback
+ *
+ * @param h computation handle
+ * @param msg response we got, NULL on errors
+ * @param status processing status code
+ */
+typedef void
+(*GNUNET_SCALARPRODUCT_ResponseMessageHandler) (
+  struct GNUNET_SCALARPRODUCT_ComputationHandle *h,
+  const struct ClientResponseMessage *msg,
+  enum GNUNET_SCALARPRODUCT_ResponseStatus status);
+
+
+/**
+ * A handle returned for each computation
+ */
+struct GNUNET_SCALARPRODUCT_ComputationHandle
+{
+  /**
+   * Our configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Current connection to the scalarproduct service.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Function to call after transmission of the request (Bob).
+   */
+  GNUNET_SCALARPRODUCT_ContinuationWithStatus cont_status;
+
+  /**
+   * Function to call after transmission of the request (Alice).
+   */
+  GNUNET_SCALARPRODUCT_DatumProcessor cont_datum;
+
+  /**
+   * Closure for @e cont_status or @e cont_datum.
+   */
+  void *cont_cls;
+
+  /**
+   * API internal callback for results and failures to be forwarded to
+   * the client.
+   */
+  GNUNET_SCALARPRODUCT_ResponseMessageHandler response_proc;
+
+  /**
+   * The shared session key identifying this computation
+   */
+  struct GNUNET_HashCode key;
+};
+
+
+/**
+ * Called when a response is received from the service. Perform basic
+ * check that the message is well-formed.
+ *
+ * @param cls Pointer to the Master Context
+ * @param message Pointer to the data received in response
+ * @return #GNUNET_OK if @a message is well-formed
+ */
+static int
+check_response (void *cls,
+                const struct ClientResponseMessage *message)
+{
+  if (ntohs (message->header.size) !=
+      ntohl (message->product_length) + sizeof(struct ClientResponseMessage))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handles the STATUS received from the service for a response, does
+ * not contain a payload.  Called when we participate as "Bob" via
+ * #GNUNET_SCALARPRODUCT_accept_computation().
+ *
+ * @param h our Handle
+ * @param msg the response received
+ * @param status the condition the request was terminated with (eg: disconnect)
+ */
+static void
+process_status_message (struct GNUNET_SCALARPRODUCT_ComputationHandle *h,
+                        const struct ClientResponseMessage *msg,
+                        enum GNUNET_SCALARPRODUCT_ResponseStatus status)
+{
+  if (NULL != h->cont_status)
+    h->cont_status (h->cont_cls,
+                    status);
+  GNUNET_SCALARPRODUCT_cancel (h);
+}
+
+
+/**
+ * Called when a response is received from the service. After basic
+ * check, the handler in `h->response_proc` is called. This functions
+ * handles the response to the client which used the API.
+ *
+ * @param cls Pointer to the Master Context
+ * @param message Pointer to the data received in response
+ */
+static void
+handle_response (void *cls,
+                 const struct ClientResponseMessage *message)
+{
+  struct GNUNET_SCALARPRODUCT_ComputationHandle *h = cls;
+  enum GNUNET_SCALARPRODUCT_ResponseStatus status;
+
+  status = (enum GNUNET_SCALARPRODUCT_ResponseStatus) ntohl (message->status);
+  h->response_proc (h,
+                    message,
+                    status);
+}
+
+
+/**
+ * Check if the keys for all given elements are unique.
+ *
+ * @param elements elements to check
+ * @param element_count size of the @a elements array
+ * @return #GNUNET_OK if all keys are unique
+ */
+static int
+check_unique (const struct GNUNET_SCALARPRODUCT_Element *elements,
+              uint32_t element_count)
+{
+  struct GNUNET_CONTAINER_MultiHashMap *map;
+  int ok;
+
+  ok = GNUNET_OK;
+  map = GNUNET_CONTAINER_multihashmap_create (2 * element_count,
+                                              GNUNET_YES);
+  for (uint32_t i = 0; i < element_count; i++)
+    if (GNUNET_OK !=
+        GNUNET_CONTAINER_multihashmap_put (map,
+                                           &elements[i].key,
+                                           map,
+                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _ ("Keys given to SCALARPRODUCT not unique!\n"));
+      ok = GNUNET_SYSERR;
+    }
+  GNUNET_CONTAINER_multihashmap_destroy (map);
+  return ok;
+}
+
+
+/**
+ * We encountered an error communicating with the set service while
+ * performing a set operation. Report to the application.
+ *
+ * @param cls the `struct GNUNET_SCALARPRODUCT_ComputationHandle`
+ * @param error error code
+ */
+static void
+mq_error_handler (void *cls,
+                  enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_SCALARPRODUCT_ComputationHandle *h = cls;
+
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "Disconnected from SCALARPRODUCT service.\n");
+  h->response_proc (h,
+                    NULL,
+                    GNUNET_SCALARPRODUCT_STATUS_DISCONNECTED);
+}
+
+
+struct GNUNET_SCALARPRODUCT_ComputationHandle *
+GNUNET_SCALARPRODUCT_accept_computation (
+  const struct GNUNET_CONFIGURATION_Handle *cfg,
+  const struct GNUNET_HashCode *session_key,
+  const struct GNUNET_SCALARPRODUCT_Element *elements,
+  uint32_t element_count,
+  GNUNET_SCALARPRODUCT_ContinuationWithStatus cont,
+  void *cont_cls)
+{
+  struct GNUNET_SCALARPRODUCT_ComputationHandle *h
+    = GNUNET_new (struct GNUNET_SCALARPRODUCT_ComputationHandle);
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_var_size (response,
+                           GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT,
+                           struct ClientResponseMessage,
+                           h),
+    GNUNET_MQ_handler_end ()
+  };
+  struct GNUNET_MQ_Envelope *env;
+  struct BobComputationMessage *msg;
+  struct ComputationBobCryptodataMultipartMessage *mmsg;
+  uint32_t size;
+  uint16_t possible;
+  uint16_t todo;
+  uint32_t element_count_transfered;
+
+
+  if (GNUNET_SYSERR == check_unique (elements,
+                                     element_count))
+    return NULL;
+  h->cont_status = cont;
+  h->cont_cls = cont_cls;
+  h->response_proc = &process_status_message;
+  h->cfg = cfg;
+  h->key = *session_key;
+  h->mq = GNUNET_CLIENT_connect (cfg,
+                                 "scalarproduct-bob",
+                                 handlers,
+                                 &mq_error_handler,
+                                 h);
+  if (NULL == h->mq)
+  {
+    /* scalarproduct configuration error */
+    GNUNET_break (0);
+    GNUNET_free (h);
+    return NULL;
+  }
+  possible = (GNUNET_MAX_MESSAGE_SIZE - 1 - sizeof(struct
+                                                   BobComputationMessage))
+             / sizeof(struct GNUNET_SCALARPRODUCT_Element);
+  todo = GNUNET_MIN (possible,
+                     element_count);
+  size = todo * sizeof(struct GNUNET_SCALARPRODUCT_Element);
+  env = GNUNET_MQ_msg_extra (msg,
+                             size,
+                             GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB);
+  msg->element_count_total = htonl (element_count);
+  msg->element_count_contained = htonl (todo);
+  msg->session_key = *session_key;
+  GNUNET_memcpy (&msg[1],
+                 elements,
+                 size);
+  element_count_transfered = todo;
+  GNUNET_MQ_send (h->mq,
+                  env);
+  possible = (GNUNET_MAX_MESSAGE_SIZE - 1 - sizeof(*mmsg))
+             / sizeof(struct GNUNET_SCALARPRODUCT_Element);
+  while (element_count_transfered < element_count)
+  {
+    todo = GNUNET_MIN (possible,
+                       element_count - element_count_transfered);
+    size = todo * sizeof(struct GNUNET_SCALARPRODUCT_Element);
+    env = GNUNET_MQ_msg_extra (mmsg,
+                               size,
+                               GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_BOB);
+    mmsg->element_count_contained = htonl (todo);
+    GNUNET_memcpy (&mmsg[1],
+                   &elements[element_count_transfered],
+                   size);
+    element_count_transfered += todo;
+    GNUNET_MQ_send (h->mq,
+                    env);
+  }
+  return h;
+}
+
+
+/**
+ * Handles the RESULT received from the service for a request, should
+ * contain a result MPI value.  Called when we participate as "Alice" via
+ * #GNUNET_SCALARPRODUCT_start_computation().
+ *
+ * @param h our Handle
+ * @param msg Pointer to the response received
+ * @param status the condition the request was terminated with (eg: disconnect)
+ */
+static void
+process_result_message (struct GNUNET_SCALARPRODUCT_ComputationHandle *h,
+                        const struct ClientResponseMessage *msg,
+                        enum GNUNET_SCALARPRODUCT_ResponseStatus status)
+{
+  uint32_t product_len;
+  gcry_mpi_t result = NULL;
+  gcry_error_t rc;
+  gcry_mpi_t num;
+  size_t rsize;
+
+  if (GNUNET_SCALARPRODUCT_STATUS_SUCCESS == status)
+  {
+    result = gcry_mpi_new (0);
+
+    product_len = ntohl (msg->product_length);
+    if (0 < product_len)
+    {
+      rsize = 0;
+      if (0 != (rc = gcry_mpi_scan (&num, GCRYMPI_FMT_STD,
+                                    &msg[1],
+                                    product_len,
+                                    &rsize)))
+      {
+        LOG_GCRY (GNUNET_ERROR_TYPE_ERROR,
+                  "gcry_mpi_scan",
+                  rc);
+        gcry_mpi_release (result);
+        result = NULL;
+        status = GNUNET_SCALARPRODUCT_STATUS_INVALID_RESPONSE;
+      }
+      else
+      {
+        if (0 < (int32_t) ntohl (msg->range))
+          gcry_mpi_add (result, result, num);
+        else
+          gcry_mpi_sub (result, result, num);
+        gcry_mpi_release (num);
+      }
+    }
+  }
+  if (NULL != h->cont_datum)
+    h->cont_datum (h->cont_cls,
+                   status,
+                   result);
+  if (NULL != result)
+    gcry_mpi_release (result);
+  GNUNET_SCALARPRODUCT_cancel (h);
+}
+
+
+struct GNUNET_SCALARPRODUCT_ComputationHandle *
+GNUNET_SCALARPRODUCT_start_computation (
+  const struct GNUNET_CONFIGURATION_Handle *cfg,
+  const struct GNUNET_HashCode *session_key,
+  const struct GNUNET_PeerIdentity *peer,
+  const struct GNUNET_SCALARPRODUCT_Element *elements,
+  uint32_t element_count,
+  GNUNET_SCALARPRODUCT_DatumProcessor cont,
+  void *cont_cls)
+{
+  struct GNUNET_SCALARPRODUCT_ComputationHandle *h
+    = GNUNET_new (struct GNUNET_SCALARPRODUCT_ComputationHandle);
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_var_size (response,
+                           GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT,
+                           struct ClientResponseMessage,
+                           h),
+    GNUNET_MQ_handler_end ()
+  };
+  struct GNUNET_MQ_Envelope *env;
+  struct AliceComputationMessage *msg;
+  struct ComputationBobCryptodataMultipartMessage *mmsg;
+  uint32_t size;
+  uint16_t possible;
+  uint16_t todo;
+  uint32_t element_count_transfered;
+
+  if (GNUNET_SYSERR == check_unique (elements,
+                                     element_count))
+    return NULL;
+  h->mq = GNUNET_CLIENT_connect (cfg,
+                                 "scalarproduct-alice",
+                                 handlers,
+                                 &mq_error_handler,
+                                 h);
+  if (NULL == h->mq)
+  {
+    /* misconfigured scalarproduct service */
+    GNUNET_break (0);
+    GNUNET_free (h);
+    return NULL;
+  }
+  h->cont_datum = cont;
+  h->cont_cls = cont_cls;
+  h->response_proc = &process_result_message;
+  h->cfg = cfg;
+  h->key = *session_key;
+
+  possible = (GNUNET_MAX_MESSAGE_SIZE - 1 - sizeof(struct
+                                                   AliceComputationMessage))
+             / sizeof(struct GNUNET_SCALARPRODUCT_Element);
+  todo = GNUNET_MIN (possible,
+                     element_count);
+  size = todo * sizeof(struct GNUNET_SCALARPRODUCT_Element);
+  env = GNUNET_MQ_msg_extra (msg,
+                             size,
+                             GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE);
+  msg->element_count_total = htonl (element_count);
+  msg->element_count_contained = htonl (todo);
+  msg->reserved = htonl (0);
+  msg->peer = *peer;
+  msg->session_key = *session_key;
+  GNUNET_memcpy (&msg[1],
+                 elements,
+                 size);
+  GNUNET_MQ_send (h->mq,
+                  env);
+  element_count_transfered = todo;
+  possible = (GNUNET_MAX_MESSAGE_SIZE - 1 - sizeof(*mmsg))
+             / sizeof(struct GNUNET_SCALARPRODUCT_Element);
+  while (element_count_transfered < element_count)
+  {
+    todo = GNUNET_MIN (possible,
+                       element_count - element_count_transfered);
+    size = todo * sizeof(struct GNUNET_SCALARPRODUCT_Element);
+    env = GNUNET_MQ_msg_extra (mmsg,
+                               size,
+                               GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_ALICE);
+    mmsg->element_count_contained = htonl (todo);
+    GNUNET_memcpy (&mmsg[1],
+                   &elements[element_count_transfered],
+                   size);
+    element_count_transfered += todo;
+    GNUNET_MQ_send (h->mq,
+                    env);
+  }
+  return h;
+}
+
+
+/**
+ * Cancel an ongoing computation or revoke our collaboration offer.
+ * Closes the connection to the service
+ *
+ * @param h computation handle to terminate
+ */
+void
+GNUNET_SCALARPRODUCT_cancel (struct GNUNET_SCALARPRODUCT_ComputationHandle *h)
+{
+  if (NULL != h->mq)
+  {
+    GNUNET_MQ_destroy (h->mq);
+    h->mq = NULL;
+  }
+  GNUNET_free (h);
+}
+
+
+/* end of scalarproduct_api.c */
diff --git a/src/contrib/service/scalarproduct/test_ecc_scalarproduct.c b/src/contrib/service/scalarproduct/test_ecc_scalarproduct.c
new file mode 100644
index 000000000..85460cb05
--- /dev/null
+++ b/src/contrib/service/scalarproduct/test_ecc_scalarproduct.c
@@ -0,0 +1,212 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2015 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+
+ */
+/**
+ * @file util/test_ecc_scalarproduct.c
+ * @brief testcase for math behind ECC SP calculation
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include <gcrypt.h>
+
+/**
+ * Global context.
+ */
+static struct GNUNET_CRYPTO_EccDlogContext *edc;
+
+
+/**
+ * Perform SP calculation.
+ *
+ * @param avec 0-terminated vector of Alice's values
+ * @param bvec 0-terminated vector of Bob's values
+ * @return avec * bvec
+ */
+static int
+test_sp (const unsigned int *avec,
+         const unsigned int *bvec)
+{
+  unsigned int len;
+  struct GNUNET_CRYPTO_EccScalar a;
+  struct GNUNET_CRYPTO_EccScalar a_neg;
+  struct GNUNET_CRYPTO_EccPoint *g;
+  struct GNUNET_CRYPTO_EccPoint *h;
+  struct GNUNET_CRYPTO_EccPoint pg;
+  struct GNUNET_CRYPTO_EccPoint ph;
+
+  /* determine length */
+  for (len = 0; 0 != avec[len]; len++)
+    ;
+  if (0 == len)
+    return 0;
+
+  /* Alice */
+  GNUNET_CRYPTO_ecc_rnd_mpi (&a,
+                             &a_neg);
+  g = GNUNET_new_array (len,
+                        struct GNUNET_CRYPTO_EccPoint);
+  h = GNUNET_new_array (len,
+                        struct GNUNET_CRYPTO_EccPoint);
+  for (unsigned int i = 0; i < len; i++)
+  {
+    struct GNUNET_CRYPTO_EccScalar tmp;
+    struct GNUNET_CRYPTO_EccScalar ri;
+    struct GNUNET_CRYPTO_EccScalar ria;
+
+    GNUNET_CRYPTO_ecc_random_mod_n (&ri);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CRYPTO_ecc_dexp_mpi (&ri,
+                                               &g[i]));
+    /* ria = ri * a mod L, where L is the order of the main subgroup */
+    crypto_core_ed25519_scalar_mul (ria.v,
+                                    ri.v,
+                                    a.v);
+    /* tmp = ria + avec[i] */
+    {
+      int64_t val = avec[i];
+      struct GNUNET_CRYPTO_EccScalar vali;
+
+      GNUNET_assert (INT64_MIN != val);
+      GNUNET_CRYPTO_ecc_scalar_from_int (val > 0 ? val : -val,
+                                         &vali);
+      if (val > 0)
+        crypto_core_ed25519_scalar_add (tmp.v,
+                                        ria.v,
+                                        vali.v);
+      else
+        crypto_core_ed25519_scalar_sub (tmp.v,
+                                        ria.v,
+                                        vali.v);
+    }
+    /* h[i] = g^tmp = g^{ria + avec[i]} */
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CRYPTO_ecc_dexp_mpi (&tmp,
+                                               &h[i]));
+  }
+
+  /* Bob */
+  for (unsigned int i = 0; i < len; i++)
+  {
+    struct GNUNET_CRYPTO_EccPoint gm;
+    struct GNUNET_CRYPTO_EccPoint hm;
+
+    {
+      int64_t val = bvec[i];
+      struct GNUNET_CRYPTO_EccScalar vali;
+
+      GNUNET_assert (INT64_MIN != val);
+      GNUNET_CRYPTO_ecc_scalar_from_int (val > 0 ? val : -val,
+                                         &vali);
+      if (val < 0)
+        crypto_core_ed25519_scalar_negate (vali.v,
+                                           vali.v);
+      /* gm = g[i]^vali */
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CRYPTO_ecc_pmul_mpi (&g[i],
+                                                 &vali,
+                                                 &gm));
+      /* hm = h[i]^vali */
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CRYPTO_ecc_pmul_mpi (&h[i],
+                                                 &vali,
+                                                 &hm));
+    }
+    if (0 != i)
+    {
+      /* pg += gm */
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CRYPTO_ecc_add (&gm,
+                                            &pg,
+                                            &pg));
+      /* ph += hm */
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CRYPTO_ecc_add (&hm,
+                                            &ph,
+                                            &ph));
+    }
+    else
+    {
+      pg = gm;
+      ph = hm;
+    }
+  }
+  GNUNET_free (g);
+  GNUNET_free (h);
+
+  /* Alice */
+  {
+    struct GNUNET_CRYPTO_EccPoint pgi;
+    struct GNUNET_CRYPTO_EccPoint gsp;
+
+    /* pgi = pg^inv */
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CRYPTO_ecc_pmul_mpi (&pg,
+                                               &a_neg,
+                                               &pgi));
+    /* gsp = pgi + ph */
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CRYPTO_ecc_add (&pgi,
+                                          &ph,
+                                          &gsp));
+    return GNUNET_CRYPTO_ecc_dlog (edc,
+                                   &gsp);
+  }
+}
+
+
+/**
+ * Macro that checks that @a want is equal to @a have and
+ * if not returns with a failure code.
+ */
+#define CHECK(want,have) do { \
+    if (want != have) {         \
+      GNUNET_break (0);         \
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, \
+                  "Wanted %d, got %d\n", want, have);   \
+      GNUNET_CRYPTO_ecc_dlog_release (edc); \
+      return 1; \
+    } } while (0)
+
+
+int
+main (int argc, char *argv[])
+{
+  static unsigned int v11[] = { 1, 1, 0 };
+  static unsigned int v22[] = { 2, 2, 0 };
+  static unsigned int v35[] = { 3, 5, 0 };
+  static unsigned int v24[] = { 2, 4, 0 };
+
+  GNUNET_log_setup ("test-ecc-scalarproduct",
+                    "WARNING",
+                    NULL);
+  edc = GNUNET_CRYPTO_ecc_dlog_prepare (128, 128);
+  CHECK (2, test_sp (v11, v11));
+  CHECK (4, test_sp (v22, v11));
+  CHECK (8, test_sp (v35, v11));
+  CHECK (26, test_sp (v35, v24));
+  CHECK (26, test_sp (v24, v35));
+  CHECK (16, test_sp (v22, v35));
+  GNUNET_CRYPTO_ecc_dlog_release (edc);
+  return 0;
+}
+
+
+/* end of test_ecc_scalarproduct.c */
diff --git a/src/contrib/service/scalarproduct/test_scalarproduct.conf b/src/contrib/service/scalarproduct/test_scalarproduct.conf
new file mode 100644
index 000000000..9d280d1cd
--- /dev/null
+++ b/src/contrib/service/scalarproduct/test_scalarproduct.conf
@@ -0,0 +1,23 @@
+@INLINE@ ../../../contrib/conf/gnunet/no_forcestart.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-scalarproduct/
+
+[testbed]
+OVERLAY_TOPOLOGY = CLIQUE
+
+[nse]
+WORKBITS=0
+
+[scalarproduct-bob]
+#PREFIX = valgrind --leak-check=yes
+
+[scalarproduct-alice]
+#PREFIX = valgrind --leak-check=yes
+
+[ats]
+WAN_QUOTA_IN = unlimited
+WAN_QUOTA_OUT = unlimited
+
+[peerinfo]
+USE_INCLUDED_HELLOS = NO
diff --git a/src/contrib/service/scalarproduct/test_scalarproduct.sh b/src/contrib/service/scalarproduct/test_scalarproduct.sh
new file mode 100755
index 000000000..ed91cd5c4
--- /dev/null
+++ b/src/contrib/service/scalarproduct/test_scalarproduct.sh
@@ -0,0 +1,48 @@
+#!/bin/bash
+# compute a simple scalar product
+# payload for this test:
+INPUTALICE="-k CCC -e 'AB,10;RO,3;FL,3;LOL,-1;'"
+INPUTBOB="-k CCC -e 'BC,-20000;RO,1000;FL,100;LOL,24;'"
+EXPECTED="0CCC"
+
+# necessary to make the testing prefix deterministic, so we can access the config files
+PREFIX=/tmp/test-scalarproduct`date +%H%M%S`
+
+# where can we find the peers config files?
+CFGALICE="-c $PREFIX/0/config"
+CFGBOB="-c $PREFIX/1/config"
+
+# launch two peers in line topology non-interactively
+#
+# interactive mode would terminate the test immediately
+# because the rest of the script is already in stdin,
+# thus redirecting stdin does not suffice)
+# GNUNET_FORCE_LOG='scalarproduct*;;;;DEBUG'
+GNUNET_TESTING_PREFIX=$PREFIX ../testbed/gnunet-testbed-profiler -n -c test_scalarproduct.conf -p 2 &
+PID=$!
+# sleep 1 is too short on most systems, 2 works on most, 5 seems to be safe
+echo "Waiting for peers to start..."
+sleep 5
+echo "Running test..."
+
+which timeout >/dev/null 2>&1 && DO_TIMEOUT="timeout 15"
+
+# get bob's peer ID, necessary for alice
+PEERIDBOB=`${DO_TIMEOUT} gnunet-peerinfo -qs $CFGBOB`
+
+#GNUNET_LOG=';;;;DEBUG'
+${DO_TIMEOUT} gnunet-scalarproduct $CFGBOB $INPUTBOB &
+#GNUNET_LOG=';;;;DEBUG'
+RESULT=`${DO_TIMEOUT} gnunet-scalarproduct $CFGALICE $INPUTALICE -p $PEERIDBOB`
+
+# terminate the testbed
+kill $PID
+
+if [ "$RESULT" = "$EXPECTED" ]
+then
+        echo "OK"
+        exit 0
+else
+        echo "Result $RESULT, expected $EXPECTED - NOTOK"
+        exit 1
+fi
diff --git a/src/contrib/service/scalarproduct/test_scalarproduct_negative.sh b/src/contrib/service/scalarproduct/test_scalarproduct_negative.sh
new file mode 100755
index 000000000..459406836
--- /dev/null
+++ b/src/contrib/service/scalarproduct/test_scalarproduct_negative.sh
@@ -0,0 +1,49 @@
+#!/bin/bash
+# compute a simple scalar product
+# payload for this test:
+INPUTALICE="-k CCC -e 'AB,10;RO,-3;FL,-3;LOL,1;'"
+INPUTBOB="-k CCC -e 'BC,-20000;RO,1000;FL,100;LOL,24;'"
+
+# necessary to make the testing prefix deterministic, so we can access the config files
+unset XDG_DATA_HOME
+unset XDG_CONFIG_HOME
+
+PREFIX=/tmp/test-scalarproduct`date +%H%M%S`
+
+# where can we find the peers config files?
+CFGALICE="-c $PREFIX/0/config"
+CFGBOB="-c $PREFIX/1/config"
+
+which timeout >/dev/null 2>&1 && DO_TIMEOUT="timeout 15"
+
+# launch two peers in line topology non-interactively
+#
+# interactive mode would terminate the test immediately
+# because the rest of the script is already in stdin,
+# thus redirecting stdin does not suffice)
+#GNUNET_LOG='scalarproduct;;;;DEBUG'
+GNUNET_TESTING_PREFIX=$PREFIX ../testbed/gnunet-testbed-profiler -n -c test_scalarproduct.conf -p 2 &
+PID=$!
+# sleep 1 is too short on most systems, 2 works on most, 5 seems to be safe
+sleep 5
+
+# get bob's peer ID, necessary for alice
+PEERIDBOB=`${DO_TIMEOUT} gnunet-peerinfo -qs $CFGBOB`
+
+#GNUNET_LOG=';;;;DEBUG'
+${DO_TIMEOUT} gnunet-scalarproduct $CFGBOB $INPUTBOB &
+#RESULT=`GNUNET_LOG=';;;;DEBUG'
+RESULT=`${DO_TIMEOUT} gnunet-scalarproduct $CFGALICE $INPUTALICE -p $PEERIDBOB`
+
+# terminate the testbed
+kill $PID
+
+EXPECTED="-0CCC"
+if [ "$RESULT" = "$EXPECTED" ]
+then
+        echo "OK"
+        exit 0
+else
+        echo "Result $RESULT, expected $EXPECTED NOTOK"
+        exit 1
+fi
diff --git a/src/contrib/service/scalarproduct/test_scalarproduct_negativezero.sh b/src/contrib/service/scalarproduct/test_scalarproduct_negativezero.sh
new file mode 100755
index 000000000..6f80b2ea2
--- /dev/null
+++ b/src/contrib/service/scalarproduct/test_scalarproduct_negativezero.sh
@@ -0,0 +1,46 @@
+#!/bin/bash
+# compute a simple scalar product
+# payload for this test:
+INPUTALICE="-k CCC -e 'AB,10;RO,-1;FL,1;LOL,1;'"
+INPUTBOB="-k CCC -e 'BC,20;RO,1;FL,1;LOL,0;'"
+
+# necessary to make the testing prefix deterministic, so we can access the config files
+PREFIX=/tmp/test-scalarproduct`date +%H%M%S`
+
+# where can we find the peers config files?
+CFGALICE="-c $PREFIX/0/config"
+CFGBOB="-c $PREFIX/1/config"
+
+# launch two peers in line topology non-interactively
+#
+# interactive mode would terminate the test immediately
+# because the rest of the script is already in stdin,
+# thus redirecting stdin does not suffice)
+# GNUNET_LOG='scalarproduct;;;;DEBUG'
+GNUNET_TESTING_PREFIX=$PREFIX ../testbed/gnunet-testbed-profiler -n -c test_scalarproduct.conf -p 2 &
+PID=$!
+# sleep 1 is too short on most systems, 2 works on most, 5 seems to be safe
+sleep 5
+
+which timeout >/dev/null 2>&1 && DO_TIMEOUT="timeout 15"
+
+# get bob's peer ID, necessary for alice
+PEERIDBOB=`${DO_TIMEOUT} gnunet-peerinfo -qs $CFGBOB`
+
+#GNUNET_LOG=';;;;DEBUG'
+${DO_TIMEOUT} gnunet-scalarproduct $CFGBOB $INPUTBOB &
+#GNUNET_LOG=';;;;DEBUG'
+RESULT=`${DO_TIMEOUT} gnunet-scalarproduct $CFGALICE $INPUTALICE -p $PEERIDBOB`
+
+# terminate the testbed
+kill $PID
+
+EXPECTED="00"
+if [ "$RESULT" = "$EXPECTED" ]
+then
+        echo "OK"
+        exit 0
+else
+        echo "Result $RESULT NOTOK"
+        exit 1
+fi
diff --git a/src/contrib/service/secretsharing/.gitignore b/src/contrib/service/secretsharing/.gitignore
new file mode 100644
index 000000000..fe9db53a4
--- /dev/null
+++ b/src/contrib/service/secretsharing/.gitignore
@@ -0,0 +1,3 @@
+gnunet-service-secretsharing
+gnunet-secretsharing-profiler
+test_secretsharing_api
diff --git a/src/contrib/service/secretsharing/Makefile.am b/src/contrib/service/secretsharing/Makefile.am
new file mode 100644
index 000000000..d9c2b37b4
--- /dev/null
+++ b/src/contrib/service/secretsharing/Makefile.am
@@ -0,0 +1,61 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+pkgcfg_DATA = \
+  secretsharing.conf
+
+if USE_COVERAGE
+  AM_CFLAGS = -fprofile-arcs -ftest-coverage
+endif
+
+
+libexec_PROGRAMS = \
+ gnunet-service-secretsharing
+
+lib_LTLIBRARIES = \
+  libgnunetsecretsharing.la
+
+
+gnunet_service_secretsharing_SOURCES = \
+ gnunet-service-secretsharing.c \
+ secretsharing_common.c \
+ secretsharing_protocol.h
+gnunet_service_secretsharing_CFLAGS = $(AM_CFLAGS)
+gnunet_service_secretsharing_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/contrib/service/consensus/libgnunetconsensus.la \
+  $(LIBGCRYPT_LIBS) \
+  $(GN_LIBINTL)
+
+libgnunetsecretsharing_la_SOURCES = \
+  secretsharing_api.c \
+  secretsharing_common.c \
+  secretsharing.h
+libgnunetsecretsharing_la_LIBADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LIBGCRYPT_LIBS) \
+  $(LTLIBINTL)
+libgnunetsecretsharing_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)
+
+check_PROGRAMS = \
+ # test_secretsharing_api
+
+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_secretsharing_api_SOURCES = \
+ test_secretsharing_api.c
+test_secretsharing_api_LDADD = \
+  libgnunetsecretsharing.la \
+  $(top_builddir)/src/service/testing/libgnunettesting.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
+
+EXTRA_DIST = \
+  test_secretsharing.conf
diff --git a/src/contrib/service/secretsharing/gnunet-service-secretsharing.c b/src/contrib/service/secretsharing/gnunet-service-secretsharing.c
new file mode 100644
index 000000000..84338bd11
--- /dev/null
+++ b/src/contrib/service/secretsharing/gnunet-service-secretsharing.c
@@ -0,0 +1,2414 @@
+/*
+     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 secretsharing/gnunet-service-secretsharing.c
+ * @brief secret sharing service
+ * @author Florian Dold
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_time_lib.h"
+#include "gnunet_signatures.h"
+#include "gnunet_consensus_service.h"
+#include "secretsharing.h"
+#include "secretsharing_protocol.h"
+#include <gcrypt.h>
+
+
+#define EXTRA_CHECKS 1
+
+
+/**
+ * Info about a peer in a key generation session.
+ */
+struct KeygenPeerInfo
+{
+  /**
+   * Peer identity of the peer.
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /**
+   * The peer's paillier public key.
+   * Freshly generated for each keygen session.
+   */
+  struct GNUNET_CRYPTO_PaillierPublicKey paillier_public_key;
+
+  /**
+   * The peer's commitment to its presecret.
+   */
+  gcry_mpi_t presecret_commitment;
+
+  /**
+   * Commitment to the preshare that is
+   * intended for our peer.
+   */
+  gcry_mpi_t preshare_commitment;
+
+  /**
+   * Sigma (exponentiated share) for this peer.
+   */
+  gcry_mpi_t sigma;
+
+  /**
+   * Did we successfully receive the round1 element
+   * of the peer?
+   */
+  int round1_valid;
+
+  /**
+   * Did we successfully receive the round2 element
+   * of the peer?
+   */
+  int round2_valid;
+};
+
+
+/**
+ * Information about a peer in a decrypt session.
+ */
+struct DecryptPeerInfo
+{
+  /**
+   * Identity of the peer.
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /**
+   * Original index in the key generation round.
+   * Necessary for computing the lagrange coefficients.
+   */
+  unsigned int original_index;
+
+  /**
+   * Set to the partial decryption of
+   * this peer, or NULL if we did not
+   * receive a partial decryption from this
+   * peer or the zero knowledge proof failed.
+   */
+  gcry_mpi_t partial_decryption;
+};
+
+
+/**
+ * State we keep per client.
+ */
+struct ClientState;
+
+
+/**
+ * Session to establish a threshold-shared secret.
+ */
+struct KeygenSession
+{
+  /**
+   * Current consensus, used for both DKG rounds.
+   */
+  struct GNUNET_CONSENSUS_Handle *consensus;
+
+  /**
+   * Which client is this for?
+   */
+  struct ClientState *cs;
+
+  /**
+   * Randomly generated coefficients of the polynomial for sharing our
+   * pre-secret, where 'preshares[0]' is our pre-secret.  Contains 'threshold'
+   * elements, thus represents a polynomial of degree 'threshold-1', which can
+   * be interpolated with 'threshold' data points.
+   *
+   * The pre-secret-shares 'i=1,...,num_peers' are given by evaluating this
+   * polyomial at 'i' for share i.
+   */
+  gcry_mpi_t *presecret_polynomial;
+
+  /**
+   * Minimum number of shares required to restore the secret.
+   * Also the number of coefficients for the polynomial representing
+   * the sharing.  Obviously, the polynomial then has degree threshold-1.
+   */
+  unsigned int threshold;
+
+  /**
+   * Total number of peers.
+   */
+  unsigned int num_peers;
+
+  /**
+   * Index of the local peer.
+   */
+  unsigned int local_peer;
+
+  /**
+   * Information about all participating peers.
+   * Array of size 'num_peers'.
+   */
+  struct KeygenPeerInfo *info;
+
+  /**
+   * List of all peers involved in the secret sharing session.
+   */
+  struct GNUNET_PeerIdentity *peers;
+
+  /**
+   * Identifier for this session.
+   */
+  struct GNUNET_HashCode session_id;
+
+  /**
+   * Paillier private key of our peer.
+   */
+  struct GNUNET_CRYPTO_PaillierPrivateKey paillier_private_key;
+
+  /**
+   * When would we like the key to be established?
+   */
+  struct GNUNET_TIME_Absolute deadline;
+
+  /**
+   * When does the DKG start?  Necessary to compute fractions of the
+   * operation's desired time interval.
+   */
+  struct GNUNET_TIME_Absolute start_time;
+
+  /**
+   * Index of the local peer in the ordered list
+   * of peers in the session.
+   */
+  unsigned int local_peer_idx;
+
+  /**
+   * Share of our peer.  Once preshares from other peers are received, they
+   * will be added to 'my'share.
+   */
+  gcry_mpi_t my_share;
+
+  /**
+   * Public key, will be updated when a round2 element arrives.
+   */
+  gcry_mpi_t public_key;
+};
+
+
+/**
+ * Session to cooperatively decrypt a value.
+ */
+struct DecryptSession
+{
+  /**
+   * Handle to the consensus over partial decryptions.
+   */
+  struct GNUNET_CONSENSUS_Handle *consensus;
+
+  /**
+   * Which client is this for?
+   */
+  struct ClientState *cs;
+
+  /**
+   * When should we start communicating for decryption?
+   */
+  struct GNUNET_TIME_Absolute start;
+
+  /**
+   * When would we like the ciphertext to be
+   * decrypted?
+   */
+  struct GNUNET_TIME_Absolute deadline;
+
+  /**
+   * Ciphertext we want to decrypt.
+   */
+  struct GNUNET_SECRETSHARING_Ciphertext ciphertext;
+
+  /**
+   * Share of the local peer.
+   * Contains other important information, such as
+   * the list of other peers.
+   */
+  struct GNUNET_SECRETSHARING_Share *share;
+
+  /**
+   * State information about other peers.
+   */
+  struct DecryptPeerInfo *info;
+};
+
+
+/**
+ * State we keep per client.
+ */
+struct ClientState
+{
+  /**
+   * Decrypt session of the client, if any.
+   */
+  struct DecryptSession *decrypt_session;
+
+  /**
+   * Keygen session of the client, if any.
+   */
+  struct KeygenSession *keygen_session;
+
+  /**
+   * Client this is about.
+   */
+  struct GNUNET_SERVICE_Client *client;
+
+  /**
+   * MQ to talk to @a client.
+   */
+  struct GNUNET_MQ_Handle *mq;
+};
+
+
+/**
+ * The ElGamal prime field order as libgcrypt mpi.
+ * Initialized in #init_crypto_constants.
+ */
+static gcry_mpi_t elgamal_q;
+
+/**
+ * Modulus of the prime field used for ElGamal.
+ * Initialized in #init_crypto_constants.
+ */
+static gcry_mpi_t elgamal_p;
+
+/**
+ * Generator for prime field of order 'elgamal_q'.
+ * Initialized in #init_crypto_constants.
+ */
+static gcry_mpi_t elgamal_g;
+
+/**
+ * Peer that runs this service.
+ */
+static struct GNUNET_PeerIdentity my_peer;
+
+/**
+ * Peer that runs this service.
+ */
+static struct GNUNET_CRYPTO_EddsaPrivateKey *my_peer_private_key;
+
+/**
+ * Configuration of this service.
+ */
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+
+/**
+ * Get the peer info belonging to a peer identity in a keygen session.
+ *
+ * @param ks The keygen session.
+ * @param peer The peer identity.
+ * @return The Keygen peer info, or NULL if the peer could not be found.
+ */
+static struct KeygenPeerInfo *
+get_keygen_peer_info (const struct KeygenSession *ks,
+                      const struct GNUNET_PeerIdentity *peer)
+{
+  unsigned int i;
+
+  for (i = 0; i < ks->num_peers; i++)
+    if (0 == GNUNET_memcmp (peer, &ks->info[i].peer))
+      return &ks->info[i];
+  return NULL;
+}
+
+
+/**
+ * Get the peer info belonging to a peer identity in a decrypt session.
+ *
+ * @param ds The decrypt session.
+ * @param peer The peer identity.
+ * @return The decrypt peer info, or NULL if the peer could not be found.
+ */
+static struct DecryptPeerInfo *
+get_decrypt_peer_info (const struct DecryptSession *ds,
+                       const struct GNUNET_PeerIdentity *peer)
+{
+  unsigned int i;
+
+  for (i = 0; i < ds->share->num_peers; i++)
+    if (0 == GNUNET_memcmp (peer, &ds->info[i].peer))
+      return &ds->info[i];
+  return NULL;
+}
+
+
+/**
+ * Interpolate between two points in time.
+ *
+ * @param start start time
+ * @param end end time
+ * @param num numerator of the scale factor
+ * @param denum denumerator of the scale factor
+ */
+static struct GNUNET_TIME_Absolute
+time_between (struct GNUNET_TIME_Absolute start,
+              struct GNUNET_TIME_Absolute end,
+              int num, int denum)
+{
+  struct GNUNET_TIME_Absolute result;
+  uint64_t diff;
+
+  GNUNET_assert (start.abs_value_us <= end.abs_value_us);
+  diff = end.abs_value_us - start.abs_value_us;
+  result.abs_value_us = start.abs_value_us + ((diff * num) / denum);
+
+  return result;
+}
+
+
+/**
+ * Compare two peer identities.  Intended to be used with qsort or bsearch.
+ *
+ * @param p1 Some peer identity.
+ * @param p2 Some peer identity.
+ * @return 1 if p1 > p2, -1 if p1 < p2 and 0 if p1 == p2.
+ */
+static int
+peer_id_cmp (const void *p1, const void *p2)
+{
+  return memcmp (p1,
+                 p2,
+                 sizeof(struct GNUNET_PeerIdentity));
+}
+
+
+/**
+ * Get the index of a peer in an array of peers
+ *
+ * @param haystack Array of peers.
+ * @param n Size of @a haystack.
+ * @param needle Peer to find
+ * @return Index of @a needle in @a haystack, or -1 if peer
+ *         is not in the list.
+ */
+static int
+peer_find (const struct GNUNET_PeerIdentity *haystack, unsigned int n,
+           const struct GNUNET_PeerIdentity *needle)
+{
+  unsigned int i;
+
+  for (i = 0; i < n; i++)
+    if (0 == GNUNET_memcmp (&haystack[i],
+                            needle))
+      return i;
+  return -1;
+}
+
+
+/**
+ * Normalize the given list of peers, by including the local peer
+ * (if it is missing) and sorting the peers by their identity.
+ *
+ * @param listed Peers in the unnormalized list.
+ * @param num_listed Peers in the un-normalized list.
+ * @param[out] num_normalized Number of peers in the normalized list.
+ * @param[out] my_peer_idx Index of the local peer in the normalized list.
+ * @return Normalized list, must be free'd by the caller.
+ */
+static struct GNUNET_PeerIdentity *
+normalize_peers (struct GNUNET_PeerIdentity *listed,
+                 unsigned int num_listed,
+                 unsigned int *num_normalized,
+                 unsigned int *my_peer_idx)
+{
+  unsigned int local_peer_in_list;
+  /* number of peers in the normalized list */
+  unsigned int n;
+  struct GNUNET_PeerIdentity *normalized;
+
+  local_peer_in_list = GNUNET_YES;
+  n = num_listed;
+  if (peer_find (listed, num_listed, &my_peer) < 0)
+  {
+    local_peer_in_list = GNUNET_NO;
+    n += 1;
+  }
+
+  normalized = GNUNET_new_array (n,
+                                 struct GNUNET_PeerIdentity);
+
+  if (GNUNET_NO == local_peer_in_list)
+    normalized[n - 1] = my_peer;
+
+  GNUNET_memcpy (normalized,
+                 listed,
+                 num_listed * sizeof(struct GNUNET_PeerIdentity));
+  qsort (normalized,
+         n,
+         sizeof(struct GNUNET_PeerIdentity),
+         &peer_id_cmp);
+
+  if (NULL != my_peer_idx)
+    *my_peer_idx = peer_find (normalized, n, &my_peer);
+  if (NULL != num_normalized)
+    *num_normalized = n;
+
+  return normalized;
+}
+
+
+/**
+ * Get a the j-th lagrange coefficient for a set of indices.
+ *
+ * @param[out] coeff the lagrange coefficient
+ * @param j lagrange coefficient we want to compute
+ * @param indices indices
+ * @param num number of indices in @a indices
+ */
+static void
+compute_lagrange_coefficient (gcry_mpi_t coeff, unsigned int j,
+                              unsigned int *indices,
+                              unsigned int num)
+{
+  unsigned int i;
+  /* numerator */
+  gcry_mpi_t n;
+  /* denominator */
+  gcry_mpi_t d;
+  /* temp value for l-j */
+  gcry_mpi_t tmp;
+
+  GNUNET_assert (0 != coeff);
+
+  GNUNET_assert (0 != (n = gcry_mpi_new (0)));
+  GNUNET_assert (0 != (d = gcry_mpi_new (0)));
+  GNUNET_assert (0 != (tmp = gcry_mpi_new (0)));
+
+  gcry_mpi_set_ui (n, 1);
+  gcry_mpi_set_ui (d, 1);
+
+  for (i = 0; i < num; i++)
+  {
+    unsigned int l = indices[i];
+    if (l == j)
+      continue;
+    gcry_mpi_mul_ui (n, n, l + 1);
+    // d <- d * (l-j)
+    gcry_mpi_set_ui (tmp, l + 1);
+    gcry_mpi_sub_ui (tmp, tmp, j + 1);
+    gcry_mpi_mul (d, d, tmp);
+  }
+
+  // gcry_mpi_invm does not like negative numbers ...
+  gcry_mpi_mod (d, d, elgamal_q);
+
+  GNUNET_assert (gcry_mpi_cmp_ui (d, 0) > 0);
+
+  // now we do the actual division, with everything mod q, as we
+  // are not operating on elements from <g>, but on exponents
+  GNUNET_assert (0 != gcry_mpi_invm (d, d, elgamal_q));
+
+  gcry_mpi_mulm (coeff, n, d, elgamal_q);
+
+  gcry_mpi_release (n);
+  gcry_mpi_release (d);
+  gcry_mpi_release (tmp);
+}
+
+
+/**
+ * Destroy a decrypt session, removing it from
+ * the linked list of decrypt sessions.
+ *
+ * @param ds decrypt session to destroy
+ */
+static void
+decrypt_session_destroy (struct DecryptSession *ds)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "destroying decrypt session\n");
+  if (NULL != ds->cs)
+  {
+    ds->cs->decrypt_session = NULL;
+    ds->cs = NULL;
+  }
+  if (NULL != ds->consensus)
+  {
+    GNUNET_CONSENSUS_destroy (ds->consensus);
+    ds->consensus = NULL;
+  }
+
+  if (NULL != ds->info)
+  {
+    for (unsigned int i = 0; i < ds->share->num_peers; i++)
+    {
+      if (NULL != ds->info[i].partial_decryption)
+      {
+        gcry_mpi_release (ds->info[i].partial_decryption);
+        ds->info[i].partial_decryption = NULL;
+      }
+    }
+    GNUNET_free (ds->info);
+    ds->info = NULL;
+  }
+  if (NULL != ds->share)
+  {
+    GNUNET_SECRETSHARING_share_destroy (ds->share);
+    ds->share = NULL;
+  }
+
+  GNUNET_free (ds);
+}
+
+
+static void
+keygen_info_destroy (struct KeygenPeerInfo *info)
+{
+  if (NULL != info->sigma)
+  {
+    gcry_mpi_release (info->sigma);
+    info->sigma = NULL;
+  }
+  if (NULL != info->presecret_commitment)
+  {
+    gcry_mpi_release (info->presecret_commitment);
+    info->presecret_commitment = NULL;
+  }
+  if (NULL != info->preshare_commitment)
+  {
+    gcry_mpi_release (info->preshare_commitment);
+    info->preshare_commitment = NULL;
+  }
+}
+
+
+static void
+keygen_session_destroy (struct KeygenSession *ks)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "destroying keygen session\n");
+
+  if (NULL != ks->cs)
+  {
+    ks->cs->keygen_session = NULL;
+    ks->cs = NULL;
+  }
+  if (NULL != ks->info)
+  {
+    for (unsigned int i = 0; i < ks->num_peers; i++)
+      keygen_info_destroy (&ks->info[i]);
+    GNUNET_free (ks->info);
+    ks->info = NULL;
+  }
+
+  if (NULL != ks->consensus)
+  {
+    GNUNET_CONSENSUS_destroy (ks->consensus);
+    ks->consensus = NULL;
+  }
+
+  if (NULL != ks->presecret_polynomial)
+  {
+    for (unsigned int i = 0; i < ks->threshold; i++)
+    {
+      GNUNET_assert (NULL != ks->presecret_polynomial[i]);
+      gcry_mpi_release (ks->presecret_polynomial[i]);
+      ks->presecret_polynomial[i] = NULL;
+    }
+    GNUNET_free (ks->presecret_polynomial);
+    ks->presecret_polynomial = NULL;
+  }
+  if (NULL != ks->my_share)
+  {
+    gcry_mpi_release (ks->my_share);
+    ks->my_share = NULL;
+  }
+  if (NULL != ks->public_key)
+  {
+    gcry_mpi_release (ks->public_key);
+    ks->public_key = NULL;
+  }
+  if (NULL != ks->peers)
+  {
+    GNUNET_free (ks->peers);
+    ks->peers = NULL;
+  }
+  GNUNET_free (ks);
+}
+
+
+/**
+ * Task run during shutdown.
+ *
+ * @param cls unused
+ */
+static void
+cleanup_task (void *cls)
+{
+  /* Nothing to do! */
+}
+
+
+/**
+ * Generate the random coefficients of our pre-secret polynomial
+ *
+ * @param ks the session
+ */
+static void
+generate_presecret_polynomial (struct KeygenSession *ks)
+{
+  int i;
+  gcry_mpi_t v;
+
+  GNUNET_assert (NULL == ks->presecret_polynomial);
+  ks->presecret_polynomial = GNUNET_new_array (ks->threshold,
+                                               gcry_mpi_t);
+  for (i = 0; i < ks->threshold; i++)
+  {
+    v = ks->presecret_polynomial[i] = gcry_mpi_new (
+      GNUNET_SECRETSHARING_ELGAMAL_BITS);
+    GNUNET_assert (NULL != v);
+    // Randomize v such that 0 < v < elgamal_q.
+    // The '- 1' is necessary as bitlength(q) = bitlength(p) - 1.
+    do
+    {
+      gcry_mpi_randomize (v, GNUNET_SECRETSHARING_ELGAMAL_BITS - 1,
+                          GCRY_WEAK_RANDOM);
+    }
+    while ((gcry_mpi_cmp_ui (v, 0) == 0) || (gcry_mpi_cmp (v, elgamal_q) >= 0));
+  }
+}
+
+
+/**
+ * Consensus element handler for round one.
+ * We should get one ephemeral key for each peer.
+ *
+ * @param cls Closure (keygen session).
+ * @param element The element from consensus, or
+ *                NULL if consensus failed.
+ */
+static void
+keygen_round1_new_element (void *cls,
+                           const struct GNUNET_SET_Element *element)
+{
+  const struct GNUNET_SECRETSHARING_KeygenCommitData *d;
+  struct KeygenSession *ks = cls;
+  struct KeygenPeerInfo *info;
+
+  if (NULL == element)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "round1 consensus failed\n");
+    return;
+  }
+
+  /* elements have fixed size */
+  if (element->size != sizeof(struct GNUNET_SECRETSHARING_KeygenCommitData))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "keygen commit data with wrong size (%u) in consensus, %u expected\n",
+                (unsigned int) element->size,
+                (unsigned int) sizeof(struct
+                                      GNUNET_SECRETSHARING_KeygenCommitData));
+    return;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "got round1 element\n");
+
+  d = element->data;
+  info = get_keygen_peer_info (ks, &d->peer);
+
+  if (NULL == info)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "keygen commit data with wrong peer identity (%s) in consensus\n",
+                GNUNET_i2s (&d->peer));
+    return;
+  }
+
+  /* Check that the right amount of data has been signed. */
+  if (d->purpose.size !=
+      htonl (element->size - offsetof (struct
+                                       GNUNET_SECRETSHARING_KeygenCommitData,
+                                       purpose)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "keygen commit data with wrong signature purpose size in consensus\n");
+    return;
+  }
+
+  if (GNUNET_OK != GNUNET_CRYPTO_eddsa_verify_ (
+        GNUNET_SIGNATURE_PURPOSE_SECRETSHARING_DKG1,
+        &d->purpose, &d->signature,
+        &d->peer.public_key))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "keygen commit data with invalid signature in consensus\n");
+    return;
+  }
+  info->paillier_public_key = d->pubkey;
+  GNUNET_CRYPTO_mpi_scan_unsigned (&info->presecret_commitment, &d->commitment,
+                                   512 / 8);
+  info->round1_valid = GNUNET_YES;
+}
+
+
+/**
+ * Evaluate the polynomial with coefficients @a coeff at @a x.
+ * The i-th element in @a coeff corresponds to the coefficient of x^i.
+ *
+ * @param[out] z result of the evaluation
+ * @param coeff array of coefficients
+ * @param num_coeff number of coefficients
+ * @param x where to evaluate the polynomial
+ * @param m what group are we operating in?
+ */
+static void
+horner_eval (gcry_mpi_t z, gcry_mpi_t *coeff, unsigned int num_coeff, gcry_mpi_t
+             x, gcry_mpi_t m)
+{
+  unsigned int i;
+
+  gcry_mpi_set_ui (z, 0);
+  for (i = 0; i < num_coeff; i++)
+  {
+    // z <- zx + c
+    gcry_mpi_mul (z, z, x);
+    gcry_mpi_addm (z, z, coeff[num_coeff - i - 1], m);
+  }
+}
+
+
+static void
+keygen_round2_conclude (void *cls)
+{
+  struct KeygenSession *ks = cls;
+  struct GNUNET_SECRETSHARING_SecretReadyMessage *m;
+  struct GNUNET_MQ_Envelope *ev;
+  size_t share_size;
+  unsigned int i;
+  unsigned int j;
+  struct GNUNET_SECRETSHARING_Share *share;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "round2 conclude\n");
+
+  GNUNET_CONSENSUS_destroy (ks->consensus);
+  ks->consensus = NULL;
+
+  share = GNUNET_new (struct GNUNET_SECRETSHARING_Share);
+
+  share->num_peers = 0;
+
+  for (i = 0; i < ks->num_peers; i++)
+    if (GNUNET_YES == ks->info[i].round2_valid)
+      share->num_peers++;
+
+  share->peers = GNUNET_new_array (share->num_peers,
+                                   struct GNUNET_PeerIdentity);
+  share->sigmas =
+    GNUNET_new_array (share->num_peers,
+                      struct GNUNET_SECRETSHARING_FieldElement);
+  share->original_indices = GNUNET_new_array (share->num_peers,
+                                              uint16_t);
+
+  /* maybe we're not even in the list of peers? */
+  share->my_peer = share->num_peers;
+
+  j = 0; /* running index of valid peers */
+  for (i = 0; i < ks->num_peers; i++)
+  {
+    if (GNUNET_YES == ks->info[i].round2_valid)
+    {
+      share->peers[j] = ks->info[i].peer;
+      GNUNET_CRYPTO_mpi_print_unsigned (&share->sigmas[j],
+                                        GNUNET_SECRETSHARING_ELGAMAL_BITS / 8,
+                                        ks->info[i].sigma);
+      share->original_indices[i] = j;
+      if (0 == GNUNET_memcmp (&share->peers[i], &my_peer))
+        share->my_peer = j;
+      j += 1;
+    }
+  }
+
+  if (share->my_peer == share->num_peers)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "P%u: peer identity not in share\n",
+                ks->local_peer_idx);
+  }
+
+  GNUNET_CRYPTO_mpi_print_unsigned (&share->my_share,
+                                    GNUNET_SECRETSHARING_ELGAMAL_BITS / 8,
+                                    ks->my_share);
+  GNUNET_CRYPTO_mpi_print_unsigned (&share->public_key,
+                                    GNUNET_SECRETSHARING_ELGAMAL_BITS / 8,
+                                    ks->public_key);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "keygen completed with %u peers\n",
+              share->num_peers);
+
+  /* Write the share. If 0 peers completed the dkg, an empty
+   * share will be sent. */
+
+  GNUNET_assert (GNUNET_OK == GNUNET_SECRETSHARING_share_write (share, NULL, 0,
+                                                                &share_size));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "writing share of size %u\n",
+              (unsigned int) share_size);
+
+  ev = GNUNET_MQ_msg_extra (m, share_size,
+                            GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_SECRET_READY);
+
+  GNUNET_assert (GNUNET_OK == GNUNET_SECRETSHARING_share_write (share, &m[1],
+                                                                share_size,
+                                                                NULL));
+
+  GNUNET_SECRETSHARING_share_destroy (share);
+  share = NULL;
+
+  GNUNET_MQ_send (ks->cs->mq,
+                  ev);
+}
+
+
+static void
+restore_fair (const struct GNUNET_CRYPTO_PaillierPublicKey *ppub,
+              const struct GNUNET_SECRETSHARING_FairEncryption *fe,
+              gcry_mpi_t x, gcry_mpi_t xres)
+{
+  gcry_mpi_t a_1;
+  gcry_mpi_t a_2;
+  gcry_mpi_t b_1;
+  gcry_mpi_t b_2;
+  gcry_mpi_t big_a;
+  gcry_mpi_t big_b;
+  gcry_mpi_t big_t;
+  gcry_mpi_t n;
+  gcry_mpi_t t_1;
+  gcry_mpi_t t_2;
+  gcry_mpi_t t;
+  gcry_mpi_t r;
+  gcry_mpi_t v;
+
+
+  GNUNET_assert (NULL != (n = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (t = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (t_1 = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (t_2 = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (r = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (big_t = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (v = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (big_a = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (big_b = gcry_mpi_new (0)));
+
+  // a = (N,0)^T
+  GNUNET_CRYPTO_mpi_scan_unsigned (&a_1,
+                                   ppub,
+                                   sizeof(struct
+                                          GNUNET_CRYPTO_PaillierPublicKey));
+  GNUNET_assert (NULL != (a_2 = gcry_mpi_new (0)));
+  gcry_mpi_set_ui (a_2, 0);
+  // b = (x,1)^T
+  GNUNET_assert (NULL != (b_1 = gcry_mpi_new (0)));
+  gcry_mpi_set (b_1, x);
+  GNUNET_assert (NULL != (b_2 = gcry_mpi_new (0)));
+  gcry_mpi_set_ui (b_2, 1);
+
+  // A = a DOT a
+  gcry_mpi_mul (t, a_1, a_1);
+  gcry_mpi_mul (big_a, a_2, a_2);
+  gcry_mpi_add (big_a, big_a, t);
+
+  // B = b DOT b
+  gcry_mpi_mul (t, b_1, b_1);
+  gcry_mpi_mul (big_b, b_2, b_2);
+  gcry_mpi_add (big_b, big_b, t);
+
+  while (1)
+  {
+    // n = a DOT b
+    gcry_mpi_mul (t, a_1, b_1);
+    gcry_mpi_mul (n, a_2, b_2);
+    gcry_mpi_add (n, n, t);
+
+    // r = nearest(n/B)
+    gcry_mpi_div (r, NULL, n, big_b, 0);
+
+    // T := A - 2rn + rrB
+    gcry_mpi_mul (v, r, n);
+    gcry_mpi_mul_ui (v, v, 2);
+    gcry_mpi_sub (big_t, big_a, v);
+    gcry_mpi_mul (v, r, r);
+    gcry_mpi_mul (v, v, big_b);
+    gcry_mpi_add (big_t, big_t, v);
+
+    if (gcry_mpi_cmp (big_t, big_b) >= 0)
+    {
+      break;
+    }
+
+    // t = a - rb
+    gcry_mpi_mul (v, r, b_1);
+    gcry_mpi_sub (t_1, a_1, v);
+    gcry_mpi_mul (v, r, b_2);
+    gcry_mpi_sub (t_2, a_2, v);
+
+    // a = b
+    gcry_mpi_set (a_1, b_1);
+    gcry_mpi_set (a_2, b_2);
+    // b = t
+    gcry_mpi_set (b_1, t_1);
+    gcry_mpi_set (b_2, t_2);
+
+    gcry_mpi_set (big_a, big_b);
+    gcry_mpi_set (big_b, big_t);
+  }
+
+  gcry_mpi_set (xres, b_2);
+  gcry_mpi_invm (xres, xres, elgamal_q);
+  gcry_mpi_mulm (xres, xres, b_1, elgamal_q);
+
+  gcry_mpi_release (a_1);
+  gcry_mpi_release (a_2);
+  gcry_mpi_release (b_1);
+  gcry_mpi_release (b_2);
+  gcry_mpi_release (big_a);
+  gcry_mpi_release (big_b);
+  gcry_mpi_release (big_t);
+  gcry_mpi_release (n);
+  gcry_mpi_release (t_1);
+  gcry_mpi_release (t_2);
+  gcry_mpi_release (t);
+  gcry_mpi_release (r);
+  gcry_mpi_release (v);
+}
+
+
+static void
+get_fair_encryption_challenge (const struct
+                               GNUNET_SECRETSHARING_FairEncryption *fe,
+                               gcry_mpi_t *e)
+{
+  struct
+  {
+    struct GNUNET_CRYPTO_PaillierCiphertext c;
+    char h[GNUNET_SECRETSHARING_ELGAMAL_BITS / 8];
+    char t1[GNUNET_SECRETSHARING_ELGAMAL_BITS / 8];
+    char t2[GNUNET_CRYPTO_PAILLIER_BITS * 2 / 8];
+  } hash_data;
+  struct GNUNET_HashCode e_hash;
+
+  memset (&hash_data,
+          0,
+          sizeof(hash_data));
+  GNUNET_memcpy (&hash_data.c, &fe->c, sizeof(struct
+                                              GNUNET_CRYPTO_PaillierCiphertext));
+  GNUNET_memcpy (&hash_data.h, &fe->h, GNUNET_SECRETSHARING_ELGAMAL_BITS / 8);
+  GNUNET_memcpy (&hash_data.t1, &fe->t1, GNUNET_SECRETSHARING_ELGAMAL_BITS / 8);
+  GNUNET_memcpy (&hash_data.t2, &fe->t2, GNUNET_CRYPTO_PAILLIER_BITS * 2 / 8);
+  GNUNET_CRYPTO_hash (&hash_data,
+                      sizeof(hash_data),
+                      &e_hash);
+  /* This allocates "e" */
+  GNUNET_CRYPTO_mpi_scan_unsigned (e,
+                                   &e_hash,
+                                   sizeof(struct GNUNET_HashCode));
+  gcry_mpi_mod (*e, *e, elgamal_q);
+}
+
+
+static int
+verify_fair (const struct GNUNET_CRYPTO_PaillierPublicKey *ppub,
+             const struct GNUNET_SECRETSHARING_FairEncryption *fe)
+{
+  gcry_mpi_t n;
+  gcry_mpi_t n_sq;
+  gcry_mpi_t z;
+  gcry_mpi_t t1;
+  gcry_mpi_t t2;
+  gcry_mpi_t e;
+  gcry_mpi_t w;
+  gcry_mpi_t tmp1;
+  gcry_mpi_t tmp2;
+  gcry_mpi_t y;
+  gcry_mpi_t big_y;
+  int res;
+
+  GNUNET_assert (NULL != (n_sq = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (tmp1 = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (tmp2 = gcry_mpi_new (0)));
+
+  get_fair_encryption_challenge (fe,
+                                 &e /* this allocates e */);
+
+  GNUNET_CRYPTO_mpi_scan_unsigned (&n,
+                                   ppub,
+                                   sizeof(struct
+                                          GNUNET_CRYPTO_PaillierPublicKey));
+  GNUNET_CRYPTO_mpi_scan_unsigned (&t1, fe->t1, GNUNET_CRYPTO_PAILLIER_BITS
+                                   / 8);
+  GNUNET_CRYPTO_mpi_scan_unsigned (&z, fe->z,
+                                   GNUNET_SECRETSHARING_ELGAMAL_BITS / 8);
+  GNUNET_CRYPTO_mpi_scan_unsigned (&y, fe->h,
+                                   GNUNET_SECRETSHARING_ELGAMAL_BITS / 8);
+  GNUNET_CRYPTO_mpi_scan_unsigned (&w, fe->w, GNUNET_CRYPTO_PAILLIER_BITS / 8);
+  GNUNET_CRYPTO_mpi_scan_unsigned (&big_y, fe->c.bits,
+                                   GNUNET_CRYPTO_PAILLIER_BITS * 2 / 8);
+  GNUNET_CRYPTO_mpi_scan_unsigned (&t2, fe->t2, GNUNET_CRYPTO_PAILLIER_BITS
+                                   * 2 / 8);
+  gcry_mpi_mul (n_sq, n, n);
+
+  // tmp1 = g^z
+  gcry_mpi_powm (tmp1, elgamal_g, z, elgamal_p);
+  // tmp2 = y^{-e}
+  gcry_mpi_powm (tmp1, y, e, elgamal_p);
+  gcry_mpi_invm (tmp1, tmp1, elgamal_p);
+  // tmp1 = tmp1 * tmp2
+  gcry_mpi_mulm (tmp1, tmp1, tmp2, elgamal_p);
+
+  if (0 == gcry_mpi_cmp (t1, tmp1))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "fair encryption invalid (t1)\n");
+    res = GNUNET_NO;
+    goto cleanup;
+  }
+
+  gcry_mpi_powm (big_y, big_y, e, n_sq);
+  gcry_mpi_invm (big_y, big_y, n_sq);
+
+  gcry_mpi_add_ui (tmp1, n, 1);
+  gcry_mpi_powm (tmp1, tmp1, z, n_sq);
+
+  gcry_mpi_powm (tmp2, w, n, n_sq);
+
+  gcry_mpi_mulm (tmp1, tmp1, tmp2, n_sq);
+  gcry_mpi_mulm (tmp1, tmp1, big_y, n_sq);
+
+
+  if (0 == gcry_mpi_cmp (t2, tmp1))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "fair encryption invalid (t2)\n");
+    res = GNUNET_NO;
+    goto cleanup;
+  }
+
+  res = GNUNET_YES;
+
+cleanup:
+
+  gcry_mpi_release (n);
+  gcry_mpi_release (n_sq);
+  gcry_mpi_release (z);
+  gcry_mpi_release (t1);
+  gcry_mpi_release (t2);
+  gcry_mpi_release (e);
+  gcry_mpi_release (w);
+  gcry_mpi_release (tmp1);
+  gcry_mpi_release (tmp2);
+  gcry_mpi_release (y);
+  gcry_mpi_release (big_y);
+  return res;
+}
+
+
+/**
+ * Create a fair Paillier encryption of then given ciphertext.
+ *
+ * @param v the ciphertext
+ * @param[out] fe the fair encryption
+ */
+static void
+encrypt_fair (gcry_mpi_t v,
+              const struct GNUNET_CRYPTO_PaillierPublicKey *ppub,
+              struct GNUNET_SECRETSHARING_FairEncryption *fe)
+{
+  gcry_mpi_t r;
+  gcry_mpi_t s;
+  gcry_mpi_t t1;
+  gcry_mpi_t t2;
+  gcry_mpi_t z;
+  gcry_mpi_t w;
+  gcry_mpi_t n;
+  gcry_mpi_t e;
+  gcry_mpi_t n_sq;
+  gcry_mpi_t u;
+  gcry_mpi_t Y;
+  gcry_mpi_t G;
+  gcry_mpi_t h;
+
+  GNUNET_assert (NULL != (r = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (s = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (t1 = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (t2 = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (z = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (w = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (n_sq = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (u = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (Y = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (G = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (h = gcry_mpi_new (0)));
+
+  GNUNET_CRYPTO_mpi_scan_unsigned (&n,
+                                   ppub,
+                                   sizeof(struct
+                                          GNUNET_CRYPTO_PaillierPublicKey));
+  gcry_mpi_mul (n_sq, n, n);
+  gcry_mpi_add_ui (G, n, 1);
+
+  do
+  {
+    gcry_mpi_randomize (u, GNUNET_CRYPTO_PAILLIER_BITS, GCRY_WEAK_RANDOM);
+  }
+  while (gcry_mpi_cmp (u, n) >= 0);
+
+  gcry_mpi_powm (t1, G, v, n_sq);
+  gcry_mpi_powm (t2, u, n, n_sq);
+  gcry_mpi_mulm (Y, t1, t2, n_sq);
+
+  GNUNET_CRYPTO_mpi_print_unsigned (fe->c.bits,
+                                    sizeof fe->c.bits,
+                                    Y);
+
+
+  gcry_mpi_randomize (r, 2048, GCRY_WEAK_RANDOM);
+  do
+  {
+    gcry_mpi_randomize (s, GNUNET_CRYPTO_PAILLIER_BITS, GCRY_WEAK_RANDOM);
+  }
+  while (gcry_mpi_cmp (s, n) >= 0);
+
+  // compute t1
+  gcry_mpi_mulm (t1, elgamal_g, r, elgamal_p);
+  // compute t2 (use z and w as temp)
+  gcry_mpi_powm (z, G, r, n_sq);
+  gcry_mpi_powm (w, s, n, n_sq);
+  gcry_mpi_mulm (t2, z, w, n_sq);
+
+
+  gcry_mpi_powm (h, elgamal_g, v, elgamal_p);
+
+  GNUNET_CRYPTO_mpi_print_unsigned (fe->h,
+                                    GNUNET_SECRETSHARING_ELGAMAL_BITS / 8,
+                                    h);
+
+  GNUNET_CRYPTO_mpi_print_unsigned (fe->t1,
+                                    GNUNET_SECRETSHARING_ELGAMAL_BITS / 8,
+                                    t1);
+
+  GNUNET_CRYPTO_mpi_print_unsigned (fe->t2,
+                                    GNUNET_CRYPTO_PAILLIER_BITS * 2 / 8,
+                                    t2);
+
+  get_fair_encryption_challenge (fe,
+                                 &e /* This allocates "e" */);
+
+  // compute z
+  gcry_mpi_mul (z, e, v);
+  gcry_mpi_addm (z, z, r, elgamal_q);
+  // compute w
+  gcry_mpi_powm (w, u, e, n);
+  gcry_mpi_mulm (w, w, s, n);
+
+  GNUNET_CRYPTO_mpi_print_unsigned (fe->z,
+                                    GNUNET_SECRETSHARING_ELGAMAL_BITS / 8,
+                                    z);
+
+  GNUNET_CRYPTO_mpi_print_unsigned (fe->w,
+                                    GNUNET_CRYPTO_PAILLIER_BITS / 8,
+                                    w);
+
+  gcry_mpi_release (n);
+  gcry_mpi_release (r);
+  gcry_mpi_release (s);
+  gcry_mpi_release (t1);
+  gcry_mpi_release (t2);
+  gcry_mpi_release (z);
+  gcry_mpi_release (w);
+  gcry_mpi_release (e);
+  gcry_mpi_release (n_sq);
+  gcry_mpi_release (u);
+  gcry_mpi_release (Y);
+  gcry_mpi_release (G);
+  gcry_mpi_release (h);
+}
+
+
+/**
+ * Insert round 2 element in the consensus, consisting of
+ * (1) The exponentiated pre-share polynomial coefficients A_{i,l}=g^{a_{i,l}}
+ * (2) The exponentiated pre-shares y_{i,j}=g^{s_{i,j}}
+ * (3) The encrypted pre-shares Y_{i,j}
+ * (4) The zero knowledge proof for fairness of
+ *     the encryption
+ *
+ * @param ks session to use
+ */
+static void
+insert_round2_element (struct KeygenSession *ks)
+{
+  struct GNUNET_SET_Element *element;
+  struct GNUNET_SECRETSHARING_KeygenRevealData *d;
+  unsigned char *pos;
+  unsigned char *last_pos;
+  size_t element_size;
+  unsigned int i;
+  gcry_mpi_t idx;
+  gcry_mpi_t v;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "P%u: Inserting round2 element\n",
+              ks->local_peer_idx);
+
+  GNUNET_assert (NULL != (v = gcry_mpi_new (
+                            GNUNET_SECRETSHARING_ELGAMAL_BITS)));
+  GNUNET_assert (NULL != (idx = gcry_mpi_new (
+                            GNUNET_SECRETSHARING_ELGAMAL_BITS)));
+
+  element_size = (sizeof(struct GNUNET_SECRETSHARING_KeygenRevealData)
+                  + sizeof(struct GNUNET_SECRETSHARING_FairEncryption)
+                  * ks->num_peers
+                  + GNUNET_SECRETSHARING_ELGAMAL_BITS / 8 * ks->threshold);
+
+  element = GNUNET_malloc (sizeof(struct GNUNET_SET_Element) + element_size);
+  element->size = element_size;
+  element->data = (void *) &element[1];
+
+  d = (void *) element->data;
+  d->peer = my_peer;
+
+  // start inserting vector elements
+  // after the fixed part of the element's data
+  pos = (void *) &d[1];
+  last_pos = pos + element_size;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "P%u: computed exp preshares\n",
+              ks->local_peer_idx);
+
+  // encrypted pre-shares
+  // and fair encryption proof
+  {
+    for (i = 0; i < ks->num_peers; i++)
+    {
+      ptrdiff_t remaining = last_pos - pos;
+      struct GNUNET_SECRETSHARING_FairEncryption *fe = (void *) pos;
+
+      GNUNET_assert (remaining > 0);
+      memset (fe, 0, sizeof *fe);
+      if (GNUNET_YES == ks->info[i].round1_valid)
+      {
+        gcry_mpi_set_ui (idx, i + 1);
+        // evaluate the polynomial
+        horner_eval (v, ks->presecret_polynomial, ks->threshold, idx,
+                     elgamal_q);
+        // encrypt the result
+        encrypt_fair (v, &ks->info[i].paillier_public_key, fe);
+      }
+      pos += sizeof *fe;
+    }
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "P%u: computed enc preshares\n",
+              ks->local_peer_idx);
+
+  // exponentiated coefficients
+  for (i = 0; i < ks->threshold; i++)
+  {
+    ptrdiff_t remaining = last_pos - pos;
+    GNUNET_assert (remaining > 0);
+    gcry_mpi_powm (v, elgamal_g, ks->presecret_polynomial[i], elgamal_p);
+    GNUNET_CRYPTO_mpi_print_unsigned (pos, GNUNET_SECRETSHARING_ELGAMAL_BITS
+                                      / 8, v);
+    pos += GNUNET_SECRETSHARING_ELGAMAL_BITS / 8;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "P%u: computed exp coefficients\n",
+              ks->local_peer_idx);
+
+
+  d->purpose.size = htonl (element_size - offsetof (struct
+                                                    GNUNET_SECRETSHARING_KeygenRevealData,
+                                                    purpose));
+  d->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_SECRETSHARING_DKG2);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CRYPTO_eddsa_sign_ (my_peer_private_key,
+                                            &d->purpose,
+                                            &d->signature));
+
+  GNUNET_CONSENSUS_insert (ks->consensus, element, NULL, NULL);
+  GNUNET_free (element);  /* FIXME: maybe stack-allocate instead? */
+
+  gcry_mpi_release (v);
+  gcry_mpi_release (idx);
+}
+
+
+static gcry_mpi_t
+keygen_reveal_get_exp_coeff (struct KeygenSession *ks,
+                             const struct
+                             GNUNET_SECRETSHARING_KeygenRevealData *d,
+                             unsigned int idx)
+{
+  unsigned char *pos;
+  gcry_mpi_t exp_coeff;
+
+  GNUNET_assert (idx < ks->threshold);
+
+  pos = (void *) &d[1];
+  // skip encrypted pre-shares
+  pos += sizeof(struct GNUNET_SECRETSHARING_FairEncryption) * ks->num_peers;
+  // skip exp. coeffs we are not interested in
+  pos += GNUNET_SECRETSHARING_ELGAMAL_BITS / 8 * idx;
+  // the first exponentiated coefficient is the public key share
+  GNUNET_CRYPTO_mpi_scan_unsigned (&exp_coeff, pos,
+                                   GNUNET_SECRETSHARING_ELGAMAL_BITS / 8);
+  return exp_coeff;
+}
+
+
+static struct GNUNET_SECRETSHARING_FairEncryption *
+keygen_reveal_get_enc_preshare (struct KeygenSession *ks,
+                                const struct
+                                GNUNET_SECRETSHARING_KeygenRevealData *d,
+                                unsigned int idx)
+{
+  unsigned char *pos;
+
+  GNUNET_assert (idx < ks->num_peers);
+
+  pos = (void *) &d[1];
+  // skip encrypted pre-shares we're not interested in
+  pos += sizeof(struct GNUNET_SECRETSHARING_FairEncryption) * idx;
+  return (struct GNUNET_SECRETSHARING_FairEncryption *) pos;
+}
+
+
+static gcry_mpi_t
+keygen_reveal_get_exp_preshare (struct KeygenSession *ks,
+                                const struct
+                                GNUNET_SECRETSHARING_KeygenRevealData *d,
+                                unsigned int idx)
+{
+  gcry_mpi_t exp_preshare;
+  struct GNUNET_SECRETSHARING_FairEncryption *fe;
+
+  GNUNET_assert (idx < ks->num_peers);
+  fe = keygen_reveal_get_enc_preshare (ks, d, idx);
+  GNUNET_CRYPTO_mpi_scan_unsigned (&exp_preshare, fe->h,
+                                   GNUNET_SECRETSHARING_ELGAMAL_BITS / 8);
+  return exp_preshare;
+}
+
+
+static void
+keygen_round2_new_element (void *cls,
+                           const struct GNUNET_SET_Element *element)
+{
+  struct KeygenSession *ks = cls;
+  const struct GNUNET_SECRETSHARING_KeygenRevealData *d;
+  struct KeygenPeerInfo *info;
+  size_t expected_element_size;
+  unsigned int j;
+  int cmp_result;
+  gcry_mpi_t tmp;
+  gcry_mpi_t public_key_share;
+  gcry_mpi_t preshare;
+
+  if (NULL == element)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "round2 consensus failed\n");
+    return;
+  }
+
+  expected_element_size = (sizeof(struct GNUNET_SECRETSHARING_KeygenRevealData)
+                           + sizeof(struct
+                                    GNUNET_SECRETSHARING_FairEncryption)
+                           * ks->num_peers
+                           + GNUNET_SECRETSHARING_ELGAMAL_BITS / 8
+                           * ks->threshold);
+
+  if (element->size != expected_element_size)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "keygen round2 data with wrong size (%u) in consensus, %u expected\n",
+                (unsigned int) element->size,
+                (unsigned int) expected_element_size);
+    return;
+  }
+
+  d = (const void *) element->data;
+
+  info = get_keygen_peer_info (ks, &d->peer);
+
+  if (NULL == info)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "keygen commit data with wrong peer identity (%s) in consensus\n",
+                GNUNET_i2s (&d->peer));
+    return;
+  }
+
+  if (GNUNET_NO == info->round1_valid)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "ignoring round2 element from peer with invalid round1 element (%s)\n",
+                GNUNET_i2s (&d->peer));
+    return;
+  }
+
+  if (GNUNET_YES == info->round2_valid)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "ignoring duplicate round2 element (%s)\n",
+                GNUNET_i2s (&d->peer));
+    return;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "got round2 element\n");
+
+  if (ntohl (d->purpose.size) !=
+      element->size - offsetof (struct GNUNET_SECRETSHARING_KeygenRevealData,
+                                purpose))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "keygen reveal data with wrong signature purpose size in consensus\n");
+    return;
+  }
+
+  if (GNUNET_OK != GNUNET_CRYPTO_eddsa_verify_ (
+        GNUNET_SIGNATURE_PURPOSE_SECRETSHARING_DKG2,
+        &d->purpose, &d->signature,
+        &d->peer.public_key))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "keygen reveal data with invalid signature in consensus\n");
+    return;
+  }
+
+  public_key_share = keygen_reveal_get_exp_coeff (ks, d, 0);
+  info->preshare_commitment = keygen_reveal_get_exp_preshare (ks, d,
+                                                              ks->local_peer_idx);
+
+  if (NULL == ks->public_key)
+  {
+    GNUNET_assert (NULL != (ks->public_key = gcry_mpi_new (0)));
+    gcry_mpi_set_ui (ks->public_key, 1);
+  }
+  gcry_mpi_mulm (ks->public_key, ks->public_key, public_key_share, elgamal_p);
+
+  gcry_mpi_release (public_key_share);
+  public_key_share = NULL;
+
+  {
+    struct GNUNET_SECRETSHARING_FairEncryption *fe =
+      keygen_reveal_get_enc_preshare (ks, d, ks->local_peer_idx);
+    GNUNET_assert (NULL != (preshare = gcry_mpi_new (0)));
+    GNUNET_CRYPTO_paillier_decrypt (&ks->paillier_private_key,
+                                    &ks->info[ks->local_peer_idx].
+                                    paillier_public_key,
+                                    &fe->c,
+                                    preshare);
+
+    // FIXME: not doing the restoration is less expensive
+    restore_fair (&ks->info[ks->local_peer_idx].paillier_public_key,
+                  fe,
+                  preshare,
+                  preshare);
+  }
+
+  GNUNET_assert (NULL != (tmp = gcry_mpi_new (0)));
+  gcry_mpi_powm (tmp, elgamal_g, preshare, elgamal_p);
+
+  cmp_result = gcry_mpi_cmp (tmp, info->preshare_commitment);
+  gcry_mpi_release (tmp);
+  tmp = NULL;
+  if (0 != cmp_result)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "P%u: Got invalid presecret from P%u\n",
+                (unsigned int) ks->local_peer_idx, (unsigned int) (info
+                                                                   - ks->info));
+    return;
+  }
+
+  if (NULL == ks->my_share)
+  {
+    GNUNET_assert (NULL != (ks->my_share = gcry_mpi_new (0)));
+  }
+  gcry_mpi_addm (ks->my_share, ks->my_share, preshare, elgamal_q);
+
+  for (j = 0; j < ks->num_peers; j++)
+  {
+    gcry_mpi_t presigma;
+    if (NULL == ks->info[j].sigma)
+    {
+      GNUNET_assert (NULL != (ks->info[j].sigma = gcry_mpi_new (0)));
+      gcry_mpi_set_ui (ks->info[j].sigma, 1);
+    }
+    presigma = keygen_reveal_get_exp_preshare (ks, d, j);
+    gcry_mpi_mulm (ks->info[j].sigma, ks->info[j].sigma, presigma, elgamal_p);
+    gcry_mpi_release (presigma);
+  }
+
+  gcry_mpi_t prod;
+  GNUNET_assert (NULL != (prod = gcry_mpi_new (0)));
+  gcry_mpi_t j_to_k;
+  GNUNET_assert (NULL != (j_to_k = gcry_mpi_new (0)));
+  // validate that the polynomial sharing matches the additive sharing
+  for (j = 0; j < ks->num_peers; j++)
+  {
+    unsigned int k;
+    int cmp_result;
+    gcry_mpi_t exp_preshare;
+    gcry_mpi_set_ui (prod, 1);
+    for (k = 0; k < ks->threshold; k++)
+    {
+      // Using pow(double,double) is a bit sketchy.
+      // We count players from 1, but shares from 0.
+      gcry_mpi_t tmp;
+      gcry_mpi_set_ui (j_to_k, (unsigned int) pow (j + 1, k));
+      tmp = keygen_reveal_get_exp_coeff (ks, d, k);
+      gcry_mpi_powm (tmp, tmp, j_to_k, elgamal_p);
+      gcry_mpi_mulm (prod, prod, tmp, elgamal_p);
+      gcry_mpi_release (tmp);
+    }
+    exp_preshare = keygen_reveal_get_exp_preshare (ks, d, j);
+    gcry_mpi_mod (exp_preshare, exp_preshare, elgamal_p);
+    cmp_result = gcry_mpi_cmp (prod, exp_preshare);
+    gcry_mpi_release (exp_preshare);
+    exp_preshare = NULL;
+    if (0 != cmp_result)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "P%u: reveal data from P%u incorrect\n",
+                  ks->local_peer_idx, j);
+      /* no need for further verification, round2 stays invalid ... */
+      return;
+    }
+  }
+
+  // TODO: verify proof of fair encryption (once implemented)
+  for (j = 0; j < ks->num_peers; j++)
+  {
+    struct GNUNET_SECRETSHARING_FairEncryption *fe =
+      keygen_reveal_get_enc_preshare (ks, d, j);
+    if (GNUNET_YES != verify_fair (&ks->info[j].paillier_public_key, fe))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "P%u: reveal data from P%u incorrect (fair encryption)\n",
+                  ks->local_peer_idx, j);
+      return;
+    }
+  }
+
+  info->round2_valid = GNUNET_YES;
+
+  gcry_mpi_release (preshare);
+  gcry_mpi_release (prod);
+  gcry_mpi_release (j_to_k);
+}
+
+
+/**
+ * Called when the first consensus round has concluded.
+ * Will initiate the second round.
+ *
+ * @param cls closure
+ */
+static void
+keygen_round1_conclude (void *cls)
+{
+  struct KeygenSession *ks = cls;
+
+  GNUNET_CONSENSUS_destroy (ks->consensus);
+
+  ks->consensus = GNUNET_CONSENSUS_create (cfg, ks->num_peers, ks->peers,
+                                           &ks->session_id,
+                                           time_between (ks->start_time,
+                                                         ks->deadline, 1, 2),
+                                           ks->deadline,
+                                           keygen_round2_new_element, ks);
+
+  insert_round2_element (ks);
+
+  GNUNET_CONSENSUS_conclude (ks->consensus,
+                             keygen_round2_conclude,
+                             ks);
+}
+
+
+/**
+ * Insert the ephemeral key and the presecret commitment
+ * of this peer in the consensus of the given session.
+ *
+ * @param ks session to use
+ */
+static void
+insert_round1_element (struct KeygenSession *ks)
+{
+  struct GNUNET_SET_Element *element;
+  struct GNUNET_SECRETSHARING_KeygenCommitData *d;
+  // g^a_{i,0}
+  gcry_mpi_t v;
+  // big-endian representation of 'v'
+  unsigned char v_data[GNUNET_SECRETSHARING_ELGAMAL_BITS / 8];
+
+  element = GNUNET_malloc (sizeof *element + sizeof *d);
+  d = (void *) &element[1];
+  element->data = d;
+  element->size = sizeof *d;
+
+  d->peer = my_peer;
+
+  GNUNET_assert (0 != (v = gcry_mpi_new (GNUNET_SECRETSHARING_ELGAMAL_BITS)));
+
+  gcry_mpi_powm (v, elgamal_g, ks->presecret_polynomial[0], elgamal_p);
+
+  GNUNET_CRYPTO_mpi_print_unsigned (v_data, GNUNET_SECRETSHARING_ELGAMAL_BITS
+                                    / 8, v);
+
+  GNUNET_CRYPTO_hash (v_data, GNUNET_SECRETSHARING_ELGAMAL_BITS / 8,
+                      &d->commitment);
+
+  d->pubkey = ks->info[ks->local_peer_idx].paillier_public_key;
+
+  d->purpose.size = htonl ((sizeof *d) - offsetof (struct
+                                                   GNUNET_SECRETSHARING_KeygenCommitData,
+                                                   purpose));
+  d->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_SECRETSHARING_DKG1);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CRYPTO_eddsa_sign_ (my_peer_private_key,
+                                            &d->purpose,
+                                            &d->signature));
+
+  GNUNET_CONSENSUS_insert (ks->consensus, element, NULL, NULL);
+
+  gcry_mpi_release (v);
+  GNUNET_free (element);
+}
+
+
+/**
+ * Check that @a msg is well-formed.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+static int
+check_client_keygen (void *cls,
+                     const struct GNUNET_SECRETSHARING_CreateMessage *msg)
+{
+  unsigned int num_peers = ntohs (msg->num_peers);
+
+  if (ntohs (msg->header.size) - sizeof(*msg) !=
+      num_peers * sizeof(struct GNUNET_PeerIdentity))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Functions with this signature are called whenever a message is
+ * received.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ */
+static void
+handle_client_keygen (void *cls,
+                      const struct GNUNET_SECRETSHARING_CreateMessage *msg)
+{
+  struct ClientState *cs = cls;
+  struct KeygenSession *ks;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "client requested key generation\n");
+  if (NULL != cs->keygen_session)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  ks = GNUNET_new (struct KeygenSession);
+  ks->cs = cs;
+  cs->keygen_session = ks;
+  ks->deadline = GNUNET_TIME_absolute_ntoh (msg->deadline);
+  ks->threshold = ntohs (msg->threshold);
+  ks->num_peers = ntohs (msg->num_peers);
+
+  ks->peers = normalize_peers ((struct GNUNET_PeerIdentity *) &msg[1],
+                               ks->num_peers,
+                               &ks->num_peers,
+                               &ks->local_peer_idx);
+
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "first round of consensus with %u peers\n",
+              ks->num_peers);
+  ks->consensus = GNUNET_CONSENSUS_create (cfg,
+                                           ks->num_peers,
+                                           ks->peers,
+                                           &msg->session_id,
+                                           GNUNET_TIME_absolute_ntoh (
+                                             msg->start),
+                                           GNUNET_TIME_absolute_ntoh (
+                                             msg->deadline),
+                                           keygen_round1_new_element,
+                                           ks);
+
+  ks->info = GNUNET_new_array (ks->num_peers,
+                               struct KeygenPeerInfo);
+
+  for (unsigned int i = 0; i < ks->num_peers; i++)
+    ks->info[i].peer = ks->peers[i];
+
+  GNUNET_CRYPTO_paillier_create (
+    &ks->info[ks->local_peer_idx].paillier_public_key,
+    &ks->paillier_private_key);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "P%u: Generated paillier key pair\n",
+              ks->local_peer_idx);
+  generate_presecret_polynomial (ks);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "P%u: Generated presecret polynomial\n",
+              ks->local_peer_idx);
+  insert_round1_element (ks);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "P%u: Concluding for round 1\n",
+              ks->local_peer_idx);
+  GNUNET_CONSENSUS_conclude (ks->consensus,
+                             keygen_round1_conclude,
+                             ks);
+  GNUNET_SERVICE_client_continue (cs->client);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "P%u: Waiting for round 1 elements ...\n",
+              ks->local_peer_idx);
+}
+
+
+/**
+ * Called when the partial decryption consensus concludes.
+ */
+static void
+decrypt_conclude (void *cls)
+{
+  struct DecryptSession *ds = cls;
+  struct GNUNET_SECRETSHARING_DecryptResponseMessage *msg;
+  struct GNUNET_MQ_Envelope *ev;
+  gcry_mpi_t lagrange;
+  gcry_mpi_t m;
+  gcry_mpi_t tmp;
+  gcry_mpi_t c_2;
+  gcry_mpi_t prod;
+  unsigned int *indices;
+  unsigned int num;
+  unsigned int i;
+  unsigned int j;
+
+  GNUNET_CONSENSUS_destroy (ds->consensus);
+  ds->consensus = NULL;
+
+  GNUNET_assert (0 != (lagrange = gcry_mpi_new (0)));
+  GNUNET_assert (0 != (m = gcry_mpi_new (0)));
+  GNUNET_assert (0 != (tmp = gcry_mpi_new (0)));
+  GNUNET_assert (0 != (prod = gcry_mpi_new (0)));
+
+  num = 0;
+  for (i = 0; i < ds->share->num_peers; i++)
+    if (NULL != ds->info[i].partial_decryption)
+      num++;
+
+  indices = GNUNET_new_array (num,
+                              unsigned int);
+  j = 0;
+  for (i = 0; i < ds->share->num_peers; i++)
+    if (NULL != ds->info[i].partial_decryption)
+      indices[j++] = ds->info[i].original_index;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "P%u: decrypt conclude, with %u peers\n",
+              ds->share->my_peer,
+              num);
+
+  gcry_mpi_set_ui (prod, 1);
+  for (i = 0; i < num; i++)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "P%u: index of %u: %u\n",
+                ds->share->my_peer, i, indices[i]);
+    compute_lagrange_coefficient (lagrange, indices[i], indices, num);
+    // w_i^{\lambda_i}
+    gcry_mpi_powm (tmp, ds->info[indices[i]].partial_decryption, lagrange,
+                   elgamal_p);
+
+    // product of all exponentiated partiel decryptions ...
+    gcry_mpi_mulm (prod, prod, tmp, elgamal_p);
+  }
+
+  GNUNET_CRYPTO_mpi_scan_unsigned (&c_2, ds->ciphertext.c2_bits,
+                                   GNUNET_SECRETSHARING_ELGAMAL_BITS / 8);
+
+  GNUNET_assert (0 != gcry_mpi_invm (prod, prod, elgamal_p));
+  gcry_mpi_mulm (m, c_2, prod, elgamal_p);
+  ev = GNUNET_MQ_msg (msg,
+                      GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT_DONE);
+  GNUNET_CRYPTO_mpi_print_unsigned (&msg->plaintext,
+                                    GNUNET_SECRETSHARING_ELGAMAL_BITS / 8, m);
+  msg->success = htonl (1);
+  GNUNET_MQ_send (ds->cs->mq,
+                  ev);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "sent decrypt done to client\n");
+
+  GNUNET_free (indices);
+
+  gcry_mpi_release (lagrange);
+  gcry_mpi_release (m);
+  gcry_mpi_release (tmp);
+  gcry_mpi_release (prod);
+  gcry_mpi_release (c_2);
+
+  // FIXME: what if not enough peers participated?
+}
+
+
+/**
+ * Get a string representation of an MPI.
+ * The caller must free the returned string.
+ *
+ * @param mpi mpi to convert to a string
+ * @return string representation of @a mpi, must be free'd by the caller
+ */
+static char *
+mpi_to_str (gcry_mpi_t mpi)
+{
+  unsigned char *buf;
+
+  GNUNET_assert (0 == gcry_mpi_aprint (GCRYMPI_FMT_HEX, &buf, NULL, mpi));
+  return (char *) buf;
+}
+
+
+/**
+ * Called when a new partial decryption arrives.
+ */
+static void
+decrypt_new_element (void *cls,
+                     const struct GNUNET_SET_Element *element)
+{
+  struct DecryptSession *session = cls;
+  const struct GNUNET_SECRETSHARING_DecryptData *d;
+  struct DecryptPeerInfo *info;
+  struct GNUNET_HashCode challenge_hash;
+
+  /* nizk response */
+  gcry_mpi_t r;
+  /* nizk challenge */
+  gcry_mpi_t challenge;
+  /* nizk commit1, g^\beta */
+  gcry_mpi_t commit1;
+  /* nizk commit2, c_1^\beta */
+  gcry_mpi_t commit2;
+  /* homomorphic commitment to the peer's share,
+   * public key share */
+  gcry_mpi_t sigma;
+  /* partial decryption we received */
+  gcry_mpi_t w;
+  /* ciphertext component #1 */
+  gcry_mpi_t c1;
+  /* temporary variable (for comparison) #1 */
+  gcry_mpi_t tmp1;
+  /* temporary variable (for comparison) #2 */
+  gcry_mpi_t tmp2;
+
+  if (NULL == element)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "decryption failed\n");
+    /* FIXME: destroy */
+    return;
+  }
+
+  if (element->size != sizeof *d)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "element of wrong size in decrypt consensus\n");
+    return;
+  }
+
+  d = element->data;
+
+  info = get_decrypt_peer_info (session, &d->peer);
+
+  if (NULL == info)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "decrypt element from invalid peer (%s)\n",
+                GNUNET_i2s (&d->peer));
+    return;
+  }
+
+  if (NULL != info->partial_decryption)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "decrypt element duplicate\n");
+    return;
+  }
+
+  if (0 != GNUNET_memcmp (&d->ciphertext, &session->ciphertext))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "P%u: got decrypt element with non-matching ciphertext from P%u\n",
+                (unsigned int) session->share->my_peer, (unsigned int) (info
+                                                                        -
+                                                                        session
+                                                                        ->info));
+
+    return;
+  }
+
+
+  GNUNET_CRYPTO_hash (offsetof (struct GNUNET_SECRETSHARING_DecryptData,
+                                ciphertext) + (char *) d,
+                      offsetof (struct GNUNET_SECRETSHARING_DecryptData,
+                                nizk_response)
+                      - offsetof (struct GNUNET_SECRETSHARING_DecryptData,
+                                  ciphertext),
+                      &challenge_hash);
+
+  GNUNET_CRYPTO_mpi_scan_unsigned (&challenge, &challenge_hash,
+                                   sizeof(struct GNUNET_HashCode));
+
+  GNUNET_CRYPTO_mpi_scan_unsigned (&sigma, &session->share->sigmas[info
+                                                                   - session->
+                                                                   info],
+                                   sizeof(struct
+                                          GNUNET_SECRETSHARING_FieldElement));
+
+  GNUNET_CRYPTO_mpi_scan_unsigned (&c1, session->ciphertext.c1_bits,
+                                   sizeof(struct
+                                          GNUNET_SECRETSHARING_FieldElement));
+
+  GNUNET_CRYPTO_mpi_scan_unsigned (&commit1, &d->nizk_commit1,
+                                   sizeof(struct
+                                          GNUNET_SECRETSHARING_FieldElement));
+
+  GNUNET_CRYPTO_mpi_scan_unsigned (&commit2, &d->nizk_commit2,
+                                   sizeof(struct
+                                          GNUNET_SECRETSHARING_FieldElement));
+
+  GNUNET_CRYPTO_mpi_scan_unsigned (&r, &d->nizk_response,
+                                   sizeof(struct
+                                          GNUNET_SECRETSHARING_FieldElement));
+
+  GNUNET_CRYPTO_mpi_scan_unsigned (&w, &d->partial_decryption,
+                                   sizeof(struct
+                                          GNUNET_SECRETSHARING_FieldElement));
+
+  GNUNET_assert (NULL != (tmp1 = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (tmp2 = gcry_mpi_new (0)));
+
+  // tmp1 = g^r
+  gcry_mpi_powm (tmp1, elgamal_g, r, elgamal_p);
+
+  // tmp2 = g^\beta * \sigma^challenge
+  gcry_mpi_powm (tmp2, sigma, challenge, elgamal_p);
+  gcry_mpi_mulm (tmp2, tmp2, commit1, elgamal_p);
+
+  if (0 != gcry_mpi_cmp (tmp1, tmp2))
+  {
+    char *tmp1_str;
+    char *tmp2_str;
+
+    tmp1_str = mpi_to_str (tmp1);
+    tmp2_str = mpi_to_str (tmp2);
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "P%u: Received invalid partial decryption from P%u (eqn 1), expected %s got %s\n",
+                session->share->my_peer,
+                (unsigned int) (info - session->info),
+                tmp1_str,
+                tmp2_str);
+    GNUNET_free (tmp1_str);
+    GNUNET_free (tmp2_str);
+    goto cleanup;
+  }
+
+
+  gcry_mpi_powm (tmp1, c1, r, elgamal_p);
+
+  gcry_mpi_powm (tmp2, w, challenge, elgamal_p);
+  gcry_mpi_mulm (tmp2, tmp2, commit2, elgamal_p);
+
+
+  if (0 != gcry_mpi_cmp (tmp1, tmp2))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "P%u: Received invalid partial decryption from P%u (eqn 2)\n",
+                session->share->my_peer,
+                (unsigned int) (info - session->info));
+    goto cleanup;
+  }
+
+
+  GNUNET_CRYPTO_mpi_scan_unsigned (&info->partial_decryption,
+                                   &d->partial_decryption,
+                                   GNUNET_SECRETSHARING_ELGAMAL_BITS / 8);
+cleanup:
+  gcry_mpi_release (tmp1);
+  gcry_mpi_release (tmp2);
+  gcry_mpi_release (sigma);
+  gcry_mpi_release (commit1);
+  gcry_mpi_release (commit2);
+  gcry_mpi_release (r);
+  gcry_mpi_release (w);
+  gcry_mpi_release (challenge);
+  gcry_mpi_release (c1);
+}
+
+
+static void
+insert_decrypt_element (struct DecryptSession *ds)
+{
+  struct GNUNET_SECRETSHARING_DecryptData d;
+  struct GNUNET_SET_Element element;
+  /* our share */
+  gcry_mpi_t s;
+  /* partial decryption with our share */
+  gcry_mpi_t w;
+  /* first component of the elgamal ciphertext */
+  gcry_mpi_t c1;
+  /* nonce for dlog zkp */
+  gcry_mpi_t beta;
+  gcry_mpi_t tmp;
+  gcry_mpi_t challenge;
+  gcry_mpi_t sigma;
+  struct GNUNET_HashCode challenge_hash;
+
+  /* make vagrind happy until we implement the real deal ... */
+  memset (&d, 0, sizeof d);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "P%u: Inserting decrypt element\n",
+              ds->share->my_peer);
+
+  GNUNET_assert (ds->share->my_peer < ds->share->num_peers);
+
+  GNUNET_CRYPTO_mpi_scan_unsigned (&c1, &ds->ciphertext.c1_bits,
+                                   GNUNET_SECRETSHARING_ELGAMAL_BITS / 8);
+  GNUNET_CRYPTO_mpi_scan_unsigned (&s, &ds->share->my_share,
+                                   GNUNET_SECRETSHARING_ELGAMAL_BITS / 8);
+  GNUNET_CRYPTO_mpi_scan_unsigned (&sigma,
+                                   &ds->share->sigmas[ds->share->my_peer],
+                                   GNUNET_SECRETSHARING_ELGAMAL_BITS / 8);
+
+  GNUNET_assert (NULL != (w = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (beta = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (tmp = gcry_mpi_new (0)));
+
+  // FIXME: unnecessary, remove once crypto works
+  gcry_mpi_powm (tmp, elgamal_g, s, elgamal_p);
+  if (0 != gcry_mpi_cmp (tmp, sigma))
+  {
+    char *sigma_str = mpi_to_str (sigma);
+    char *tmp_str = mpi_to_str (tmp);
+    char *s_str = mpi_to_str (s);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Share of P%u is invalid, ref sigma %s, "
+                "computed sigma %s, s %s\n",
+                ds->share->my_peer,
+                sigma_str, tmp_str, s_str);
+    GNUNET_free (sigma_str);
+    GNUNET_free (tmp_str);
+    GNUNET_free (s_str);
+  }
+
+  gcry_mpi_powm (w, c1, s, elgamal_p);
+
+  element.data = (void *) &d;
+  element.size = sizeof(struct GNUNET_SECRETSHARING_DecryptData);
+  element.element_type = 0;
+
+  d.ciphertext = ds->ciphertext;
+  d.peer = my_peer;
+  GNUNET_CRYPTO_mpi_print_unsigned (&d.partial_decryption,
+                                    GNUNET_SECRETSHARING_ELGAMAL_BITS / 8, w);
+
+  // create the zero knowledge proof
+  // randomly choose beta such that 0 < beta < q
+  do
+  {
+    gcry_mpi_randomize (beta, GNUNET_SECRETSHARING_ELGAMAL_BITS - 1,
+                        GCRY_WEAK_RANDOM);
+  }
+  while ((gcry_mpi_cmp_ui (beta, 0) == 0) || (gcry_mpi_cmp (beta, elgamal_q) >=
+                                              0));
+  // tmp = g^beta
+  gcry_mpi_powm (tmp, elgamal_g, beta, elgamal_p);
+  GNUNET_CRYPTO_mpi_print_unsigned (&d.nizk_commit1,
+                                    GNUNET_SECRETSHARING_ELGAMAL_BITS / 8, tmp);
+  // tmp = (c_1)^beta
+  gcry_mpi_powm (tmp, c1, beta, elgamal_p);
+  GNUNET_CRYPTO_mpi_print_unsigned (&d.nizk_commit2,
+                                    GNUNET_SECRETSHARING_ELGAMAL_BITS / 8, tmp);
+
+  // the challenge is the hash of everything up to the response
+  GNUNET_CRYPTO_hash (offsetof (struct GNUNET_SECRETSHARING_DecryptData,
+                                ciphertext) + (char *) &d,
+                      offsetof (struct GNUNET_SECRETSHARING_DecryptData,
+                                nizk_response)
+                      - offsetof (struct GNUNET_SECRETSHARING_DecryptData,
+                                  ciphertext),
+                      &challenge_hash);
+
+  GNUNET_CRYPTO_mpi_scan_unsigned (&challenge, &challenge_hash,
+                                   sizeof(struct GNUNET_HashCode));
+
+  // compute the response in tmp,
+  // tmp = (c * s + beta) mod q
+  gcry_mpi_mulm (tmp, challenge, s, elgamal_q);
+  gcry_mpi_addm (tmp, tmp, beta, elgamal_q);
+
+  GNUNET_CRYPTO_mpi_print_unsigned (&d.nizk_response,
+                                    GNUNET_SECRETSHARING_ELGAMAL_BITS / 8, tmp);
+
+  d.purpose.size = htonl (element.size - offsetof (struct
+                                                   GNUNET_SECRETSHARING_DecryptData,
+                                                   purpose));
+  d.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_SECRETSHARING_DECRYPTION);
+
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CRYPTO_eddsa_sign_ (my_peer_private_key,
+                                            &d.purpose,
+                                            &d.signature));
+
+  GNUNET_CONSENSUS_insert (ds->consensus, &element, NULL, NULL);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "P%u: Inserting decrypt element done!\n",
+              ds->share->my_peer);
+
+  gcry_mpi_release (s);
+  gcry_mpi_release (w);
+  gcry_mpi_release (c1);
+  gcry_mpi_release (beta);
+  gcry_mpi_release (tmp);
+  gcry_mpi_release (challenge);
+  gcry_mpi_release (sigma);
+}
+
+
+/**
+ * Check that @a msg is well-formed.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ * @return #GNUNET_OK (check deferred a bit)
+ */
+static int
+check_client_decrypt (void *cls,
+                      const struct
+                      GNUNET_SECRETSHARING_DecryptRequestMessage *msg)
+{
+  /* we check later, it's complicated */
+  return GNUNET_OK;
+}
+
+
+/**
+ * Functions with this signature are called whenever a message is
+ * received.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ */
+static void
+handle_client_decrypt (void *cls,
+                       const struct
+                       GNUNET_SECRETSHARING_DecryptRequestMessage *msg)
+{
+  struct ClientState *cs = cls;
+  struct DecryptSession *ds;
+  struct GNUNET_HashCode session_id;
+
+  if (NULL != cs->decrypt_session)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  ds = GNUNET_new (struct DecryptSession);
+  cs->decrypt_session = ds;
+  ds->cs = cs;
+  ds->start = GNUNET_TIME_absolute_ntoh (msg->start);
+  ds->deadline = GNUNET_TIME_absolute_ntoh (msg->deadline);
+  ds->ciphertext = msg->ciphertext;
+
+  ds->share = GNUNET_SECRETSHARING_share_read (&msg[1],
+                                               ntohs (msg->header.size)
+                                               - sizeof(*msg),
+                                               NULL);
+  if (NULL == ds->share)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+
+  /* FIXME: this is probably sufficient, but kdf/hash with all values would be nicer ... */
+  GNUNET_CRYPTO_hash (&msg->ciphertext,
+                      sizeof(struct GNUNET_SECRETSHARING_Ciphertext),
+                      &session_id);
+  ds->consensus = GNUNET_CONSENSUS_create (cfg,
+                                           ds->share->num_peers,
+                                           ds->share->peers,
+                                           &session_id,
+                                           ds->start,
+                                           ds->deadline,
+                                           &decrypt_new_element,
+                                           ds);
+
+
+  ds->info = GNUNET_new_array (ds->share->num_peers,
+                               struct DecryptPeerInfo);
+  for (unsigned int i = 0; i < ds->share->num_peers; i++)
+  {
+    ds->info[i].peer = ds->share->peers[i];
+    ds->info[i].original_index = ds->share->original_indices[i];
+  }
+  insert_decrypt_element (ds);
+  GNUNET_CONSENSUS_conclude (ds->consensus,
+                             decrypt_conclude,
+                             ds);
+  GNUNET_SERVICE_client_continue (cs->client);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "decrypting with %u peers\n",
+              ds->share->num_peers);
+}
+
+
+static void
+init_crypto_constants (void)
+{
+  GNUNET_assert (0 == gcry_mpi_scan (&elgamal_q, GCRYMPI_FMT_HEX,
+                                     GNUNET_SECRETSHARING_ELGAMAL_Q_HEX, 0,
+                                     NULL));
+  GNUNET_assert (0 == gcry_mpi_scan (&elgamal_p, GCRYMPI_FMT_HEX,
+                                     GNUNET_SECRETSHARING_ELGAMAL_P_HEX, 0,
+                                     NULL));
+  GNUNET_assert (0 == gcry_mpi_scan (&elgamal_g, GCRYMPI_FMT_HEX,
+                                     GNUNET_SECRETSHARING_ELGAMAL_G_HEX, 0,
+                                     NULL));
+}
+
+
+/**
+ * Initialize secretsharing service.
+ *
+ * @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)
+{
+  cfg = c;
+  my_peer_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (c);
+  if (NULL == my_peer_private_key)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "could not access host private key\n");
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  init_crypto_constants ();
+  if (GNUNET_OK !=
+      GNUNET_CRYPTO_get_peer_identity (cfg,
+                                       &my_peer))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "could not retrieve host identity\n");
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_SCHEDULER_add_shutdown (&cleanup_task,
+                                 NULL);
+}
+
+
+/**
+ * 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)
+{
+  struct ClientState *cs = GNUNET_new (struct ClientState);;
+
+  cs->client = c;
+  cs->mq = mq;
+  return cs;
+}
+
+
+/**
+ * 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)
+{
+  struct ClientState *cs = internal_cls;
+
+  if (NULL != cs->keygen_session)
+    keygen_session_destroy (cs->keygen_session);
+
+  if (NULL != cs->decrypt_session)
+    decrypt_session_destroy (cs->decrypt_session);
+  GNUNET_free (cs);
+}
+
+
+/**
+ * Define "main" method using service macro.
+ */
+GNUNET_SERVICE_MAIN
+  ("secretsharing",
+  GNUNET_SERVICE_OPTION_NONE,
+  &run,
+  &client_connect_cb,
+  &client_disconnect_cb,
+  NULL,
+  GNUNET_MQ_hd_var_size (client_keygen,
+                         GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_GENERATE,
+                         struct GNUNET_SECRETSHARING_CreateMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (client_decrypt,
+                         GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT,
+                         struct GNUNET_SECRETSHARING_DecryptRequestMessage,
+                         NULL),
+  GNUNET_MQ_handler_end ());
diff --git a/src/contrib/service/secretsharing/meson.build b/src/contrib/service/secretsharing/meson.build
new file mode 100644
index 000000000..5f9935793
--- /dev/null
+++ b/src/contrib/service/secretsharing/meson.build
@@ -0,0 +1,45 @@
+libgnunetsecretsharing_src = ['secretsharing_api.c', 'secretsharing_common.c']
+
+gnunetservicesecretsharing_src = ['gnunet-service-secretsharing.c', 'secretsharing_common.c']
+
+configure_file(input : 'secretsharing.conf.in',
+               output : 'secretsharing.conf',
+               configuration : cdata,
+               install: true,
+               install_dir: pkgcfgdir)
+
+# FIXME needs new seti/setu
+if get_option('monolith')
+  #foreach p : libgnunetsecretsharing_src + gnunetservicesecretsharing_src
+  #  gnunet_src += 'secretsharing/' + p
+  #endforeach
+endif
+
+libgnunetsecretsharing = library('gnunetsecretsharing',
+        libgnunetsecretsharing_src,
+        soversion: '0',
+        version: '0.0.0',
+        dependencies: [libgnunetutil_dep,
+                       libgnunetstatistics_dep,
+                       gcrypt_dep,
+                       libgnunetdatacache_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir'))
+libgnunetsecretsharing_dep = declare_dependency(link_with : libgnunetsecretsharing)
+pkg.generate(libgnunetsecretsharing, url: 'https://www.gnunet.org',
+             description : 'Provides API for the secretsharing service')
+
+executable ('gnunet-service-secretsharing',
+            gnunetservicesecretsharing_src,
+            dependencies: [libgnunetsecretsharing_dep,
+                           libgnunetutil_dep,
+                           gcrypt_dep,
+                           m_dep,
+                           libgnunetconsensus_dep,
+                           libgnunetstatistics_dep,
+                           libgnunetdatacache_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir')/'gnunet'/'libexec')
+
diff --git a/src/contrib/service/secretsharing/secretsharing.conf.in b/src/contrib/service/secretsharing/secretsharing.conf.in
new file mode 100644
index 000000000..df8566abd
--- /dev/null
+++ b/src/contrib/service/secretsharing/secretsharing.conf.in
@@ -0,0 +1,20 @@
+[secretsharing]
+START_ON_DEMAND = NO
+@JAVAPORT@PORT = 2114
+HOSTNAME = localhost
+BINARY = gnunet-service-secretsharing
+ACCEPT_FROM = 127.0.0.1;
+ACCEPT_FROM6 = ::1;
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-secretsharing.sock
+UNIX_MATCH_UID = YES
+UNIX_MATCH_GID = YES
+# PREFIX = valgrind --leak-check=yes
+# DISABLE_SOCKET_FORWARDING = NO
+# USERNAME =
+# MAXBUF =
+# TIMEOUT =
+# DISABLEV6 =
+# BINDTO =
+# REJECT_FROM =
+# REJECT_FROM6 =
+# PREFIX =
diff --git a/src/contrib/service/secretsharing/secretsharing.h b/src/contrib/service/secretsharing/secretsharing.h
new file mode 100644
index 000000000..6e104ebfa
--- /dev/null
+++ b/src/contrib/service/secretsharing/secretsharing.h
@@ -0,0 +1,227 @@
+/*
+     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
+ */
+
+/**
+ * @author Florian Dold
+ * @file secretsharing/secretsharing.h
+ * @brief messages used for the secretsharing api
+ */
+#ifndef SECRETSHARING_H
+#define SECRETSHARING_H
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_time_lib.h"
+#include "gnunet_common.h"
+#include "gnunet_secretsharing_service.h"
+
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+struct GNUNET_SECRETSHARING_FieldElement
+{
+  /**
+   * Value of an element in &lt;elgamal_g&gt;.
+   */
+  unsigned char bits[GNUNET_SECRETSHARING_ELGAMAL_BITS / 8];
+};
+
+
+struct GNUNET_SECRETSHARING_CreateMessage
+{
+  /**
+   * Type: GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_GENERATE
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Session ID, will be used for consensus.
+   */
+  struct GNUNET_HashCode session_id GNUNET_PACKED;
+
+  /**
+   * Start time for communication with the other peers.
+   */
+  struct GNUNET_TIME_AbsoluteNBO start;
+
+  /**
+   * Deadline for the establishment of the crypto system.
+   */
+  struct GNUNET_TIME_AbsoluteNBO deadline;
+
+  /**
+   * Minimum number of cooperating peers to decrypt a
+   * value.
+   */
+  uint16_t threshold GNUNET_PACKED;
+
+  /**
+   * Number of peers at the end of this message.
+   */
+  uint16_t num_peers GNUNET_PACKED;
+
+  /* struct GNUNET_PeerIdentity[num_peers]; */
+};
+
+
+struct GNUNET_SECRETSHARING_ShareHeaderNBO
+{
+  /**
+   * Threshold for the key this share belongs to.
+   */
+  uint16_t threshold;
+
+  /**
+   * Peers that have the share.
+   */
+  uint16_t num_peers;
+
+  /**
+   * Index of our peer in the list.
+   */
+  uint16_t my_peer;
+
+  /**
+   * Public key. Must correspond to the product of
+   * the homomorphic share commitments.
+   */
+  struct GNUNET_SECRETSHARING_PublicKey public_key;
+
+  /**
+   * Share of 'my_peer'
+   */
+  struct GNUNET_SECRETSHARING_FieldElement my_share;
+};
+
+
+/**
+ * Notify the client that then threshold secret has been
+ * established.
+ */
+struct GNUNET_SECRETSHARING_SecretReadyMessage
+{
+  /**
+   * Type: GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_SECRET_READY
+   */
+  struct GNUNET_MessageHeader header;
+
+  /* rest: the serialized share */
+};
+
+
+struct GNUNET_SECRETSHARING_DecryptRequestMessage
+{
+  /**
+   * Type: GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT_REQUEST
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Until when should the decryption start?
+   */
+  struct GNUNET_TIME_AbsoluteNBO start;
+
+  /**
+   * Until when should the decryption be finished?
+   */
+  struct GNUNET_TIME_AbsoluteNBO deadline;
+
+  /**
+   * Ciphertext we want to decrypt.
+   */
+  struct GNUNET_SECRETSHARING_Ciphertext ciphertext;
+
+  /* the share with payload */
+};
+
+
+struct GNUNET_SECRETSHARING_DecryptResponseMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT_DONE
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Zero if decryption failed, non-zero if decryption succeeded.
+   * If the decryption failed, plaintext is also zero.
+   */
+  uint32_t success GNUNET_PACKED;
+
+  /**
+   * Decrypted plaintext.
+   */
+  struct GNUNET_SECRETSHARING_FieldElement plaintext;
+};
+
+
+GNUNET_NETWORK_STRUCT_END
+
+
+/**
+ * A share, with all values in in host byte order.
+ */
+struct GNUNET_SECRETSHARING_Share
+{
+  /**
+   * Threshold for the key this share belongs to.
+   */
+  uint16_t threshold;
+
+  /**
+   * Peers that have the share.
+   */
+  uint16_t num_peers;
+
+  /**
+   * Index of our peer in the list.
+   */
+  uint16_t my_peer;
+
+  /**
+   * Public key.  Computed from the
+   * exponentiated coefficients.
+   */
+  struct GNUNET_SECRETSHARING_PublicKey public_key;
+
+  /**
+   * Share of 'my_peer'
+   */
+  struct GNUNET_SECRETSHARING_FieldElement my_share;
+
+  /**
+   * Peer identities (includes 'my_peer')
+   */
+  struct GNUNET_PeerIdentity *peers;
+
+  /*
+   * For each peer, store elgamal_g to the peer's
+   * share.
+   */
+  struct GNUNET_SECRETSHARING_FieldElement *sigmas;
+
+  /*
+   * Original indices of peers from the DKG round.
+   */
+  uint16_t *original_indices;
+};
+
+
+#endif
diff --git a/src/contrib/service/secretsharing/secretsharing_api.c b/src/contrib/service/secretsharing/secretsharing_api.c
new file mode 100644
index 000000000..595af751f
--- /dev/null
+++ b/src/contrib/service/secretsharing/secretsharing_api.c
@@ -0,0 +1,492 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2012, 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 secretsharing/secretsharing_api.c
+ * @brief
+ * @author Florian Dold
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_secretsharing_service.h"
+#include "secretsharing.h"
+#include <gcrypt.h>
+
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "secretsharing-api", __VA_ARGS__)
+
+/**
+ * Session that will eventually establish a shared secred between
+ * the involved peers and allow encryption and cooperative decryption.
+ */
+struct GNUNET_SECRETSHARING_Session
+{
+  /**
+   * Message queue for @e client.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Called when the secret sharing is done.
+   */
+  GNUNET_SECRETSHARING_SecretReadyCallback secret_ready_cb;
+
+  /**
+   * Closure for @e secret_ready_cb.
+   */
+  void *secret_ready_cls;
+};
+
+
+/**
+ * Handle to cancel a cooperative decryption operation.
+ */
+struct GNUNET_SECRETSHARING_DecryptionHandle
+{
+  /**
+   * Message queue for @e client.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Called when the secret sharing is done.
+   */
+  GNUNET_SECRETSHARING_DecryptCallback decrypt_cb;
+
+  /**
+   * Closure for @e decrypt_cb.
+   */
+  void *decrypt_cls;
+};
+
+
+/**
+ * The ElGamal prime field order as libgcrypt mpi.
+ * Initialized in #init_crypto_constants.
+ */
+static gcry_mpi_t elgamal_q;
+
+/**
+ * Modulus of the prime field used for ElGamal.
+ * Initialized in #init_crypto_constants.
+ */
+static gcry_mpi_t elgamal_p;
+
+/**
+ * Generator for prime field of order 'elgamal_q'.
+ * Initialized in #init_crypto_constants.
+ */
+static gcry_mpi_t elgamal_g;
+
+
+/**
+ * Function to initialize #elgamal_q, #elgamal_p and #elgamal_g.
+ */
+static void
+ensure_elgamal_initialized (void)
+{
+  if (NULL != elgamal_q)
+    return; /* looks like crypto is already initialized */
+
+  GNUNET_assert (0 == gcry_mpi_scan (&elgamal_q, GCRYMPI_FMT_HEX,
+                                     GNUNET_SECRETSHARING_ELGAMAL_Q_HEX, 0,
+                                     NULL));
+  GNUNET_assert (0 == gcry_mpi_scan (&elgamal_p, GCRYMPI_FMT_HEX,
+                                     GNUNET_SECRETSHARING_ELGAMAL_P_HEX, 0,
+                                     NULL));
+  GNUNET_assert (0 == gcry_mpi_scan (&elgamal_g, GCRYMPI_FMT_HEX,
+                                     GNUNET_SECRETSHARING_ELGAMAL_G_HEX, 0,
+                                     NULL));
+}
+
+
+/**
+ * Callback invoked when there is an error communicating with
+ * the service.  Notifies the application about the error.
+ *
+ * @param cls the `struct GNUNET_SECRETSHARING_Session`
+ * @param error error code
+ */
+static void
+handle_session_client_error (void *cls,
+                             enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_SECRETSHARING_Session *s = cls;
+
+  s->secret_ready_cb (s->secret_ready_cls, NULL, NULL, 0, NULL);
+  GNUNET_SECRETSHARING_session_destroy (s);
+}
+
+
+/**
+ * Callback invoked when there is an error communicating with
+ * the service.  Notifies the application about the error.
+ *
+ * @param cls the `struct GNUNET_SECRETSHARING_DecryptionHandle`
+ * @param error error code
+ */
+static void
+handle_decrypt_client_error (void *cls,
+                             enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_SECRETSHARING_DecryptionHandle *dh = cls;
+
+  dh->decrypt_cb (dh->decrypt_cls, NULL);
+  GNUNET_SECRETSHARING_decrypt_cancel (dh);
+}
+
+
+/**
+ * Handler invoked with the final result message from
+ * secret sharing.  Decodes the message and passes the
+ * result to the application.
+ *
+ * @param cls the `struct GNUNET_SECRETSHARING_Session`
+ * @param m message with the result
+ */
+static int
+check_secret_ready (void *cls,
+                    const struct GNUNET_SECRETSHARING_SecretReadyMessage *m)
+{
+  /* FIXME: actually check m is well-formed here! */
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handler invoked with the final result message from
+ * secret sharing.  Decodes the message and passes the
+ * result to the application.
+ *
+ * @param cls the `struct GNUNET_SECRETSHARING_Session`
+ * @param m message with the result
+ */
+static void
+handle_secret_ready (void *cls,
+                     const struct GNUNET_SECRETSHARING_SecretReadyMessage *m)
+{
+  struct GNUNET_SECRETSHARING_Session *s = cls;
+  struct GNUNET_SECRETSHARING_Share *share;
+  size_t share_size;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Got secret ready message of size %u\n",
+       ntohs (m->header.size));
+  share_size = ntohs (m->header.size) - sizeof(struct
+                                               GNUNET_SECRETSHARING_SecretReadyMessage);
+
+  share = GNUNET_SECRETSHARING_share_read (&m[1],
+                                           share_size,
+                                           NULL);
+  GNUNET_assert (NULL != share);  // FIXME: this can fail!
+  // should have been checked in #check_secret_ready!
+  // FIXME: below we never check &m[1] is valid!
+  // FIXME: do we leak 'share' here?
+  s->secret_ready_cb (s->secret_ready_cls,
+                      share, /* FIXME */
+                      &share->public_key,
+                      share->num_peers,
+                      (const struct GNUNET_PeerIdentity *) &m[1]);
+
+  GNUNET_SECRETSHARING_session_destroy (s);
+}
+
+
+/**
+ * Destroy a secret sharing session.
+ * The secret ready callback will not be called.
+ *
+ * @param s session to destroy
+ */
+void
+GNUNET_SECRETSHARING_session_destroy (struct GNUNET_SECRETSHARING_Session *s)
+{
+  GNUNET_MQ_destroy (s->mq);
+  s->mq = NULL;
+  GNUNET_free (s);
+}
+
+
+/**
+ * Create a session that will eventually establish a shared secret
+ * with the other peers.
+ *
+ * @param cfg configuration to use
+ * @param num_peers number of peers in @a peers
+ * @param peers array of peers that we will share secrets with, can optionally contain the local peer
+ * @param session_id unique session id
+ * @param start When should all peers be available for sharing the secret?
+ *              Random number generation can take place before the start time.
+ * @param deadline point in time where the session must be established; taken as hint
+ *                 by underlying consensus sessions
+ * @param threshold minimum number of peers that must cooperate to decrypt a value
+ * @param cb called when the secret has been established
+ * @param cls closure for @a cb
+ */
+struct GNUNET_SECRETSHARING_Session *
+GNUNET_SECRETSHARING_create_session (const struct
+                                     GNUNET_CONFIGURATION_Handle *cfg,
+                                     unsigned int num_peers,
+                                     const struct GNUNET_PeerIdentity *peers,
+                                     const struct GNUNET_HashCode *session_id,
+                                     struct GNUNET_TIME_Absolute start,
+                                     struct GNUNET_TIME_Absolute deadline,
+                                     unsigned int threshold,
+                                     GNUNET_SECRETSHARING_SecretReadyCallback cb,
+                                     void *cls)
+{
+  struct GNUNET_SECRETSHARING_Session *s
+    = GNUNET_new (struct GNUNET_SECRETSHARING_Session);
+  struct GNUNET_MQ_MessageHandler mq_handlers[] = {
+    GNUNET_MQ_hd_var_size (secret_ready,
+                           GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_SECRET_READY,
+                           struct GNUNET_SECRETSHARING_SecretReadyMessage,
+                           s),
+    GNUNET_MQ_handler_end ()
+  };
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_SECRETSHARING_CreateMessage *msg;
+
+  s->mq = GNUNET_CLIENT_connect (cfg,
+                                 "secretsharing",
+                                 mq_handlers,
+                                 &handle_session_client_error,
+                                 s);
+  if (NULL == s->mq)
+  {
+    /* secretsharing not configured correctly */
+    GNUNET_break (0);
+    GNUNET_free (s);
+    return NULL;
+  }
+  s->secret_ready_cb = cb;
+  s->secret_ready_cls = cls;
+  ev = GNUNET_MQ_msg_extra (msg,
+                            num_peers * sizeof(struct GNUNET_PeerIdentity),
+                            GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_GENERATE);
+
+  msg->threshold = htons (threshold);
+  msg->num_peers = htons (num_peers);
+  msg->session_id = *session_id;
+  msg->start = GNUNET_TIME_absolute_hton (start);
+  msg->deadline = GNUNET_TIME_absolute_hton (deadline);
+  GNUNET_memcpy (&msg[1], peers, num_peers * sizeof(struct
+                                                    GNUNET_PeerIdentity));
+
+  GNUNET_MQ_send (s->mq, ev);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Secretsharing session created with %u peers\n",
+       num_peers);
+  return s;
+}
+
+
+static void
+handle_decrypt_done (void *cls,
+                     const struct
+                     GNUNET_SECRETSHARING_DecryptResponseMessage *m)
+{
+  struct GNUNET_SECRETSHARING_DecryptionHandle *dh = cls;
+  const struct GNUNET_SECRETSHARING_Plaintext *plaintext;
+
+  if (m->success == 0)
+    plaintext = NULL;
+  else
+    plaintext = (void *) &m->plaintext;
+  dh->decrypt_cb (dh->decrypt_cls, plaintext);
+  GNUNET_SECRETSHARING_decrypt_cancel (dh);
+}
+
+
+struct GNUNET_SECRETSHARING_DecryptionHandle *
+GNUNET_SECRETSHARING_decrypt (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                              struct GNUNET_SECRETSHARING_Share *share,
+                              const struct
+                              GNUNET_SECRETSHARING_Ciphertext *ciphertext,
+                              struct GNUNET_TIME_Absolute start,
+                              struct GNUNET_TIME_Absolute deadline,
+                              GNUNET_SECRETSHARING_DecryptCallback decrypt_cb,
+                              void *decrypt_cb_cls)
+{
+  struct GNUNET_SECRETSHARING_DecryptionHandle *s
+    = GNUNET_new (struct GNUNET_SECRETSHARING_DecryptionHandle);
+  struct GNUNET_MQ_MessageHandler mq_handlers[] = {
+    GNUNET_MQ_hd_fixed_size (decrypt_done,
+                             GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT_DONE,
+                             struct GNUNET_SECRETSHARING_DecryptResponseMessage,
+                             s),
+    GNUNET_MQ_handler_end ()
+  };
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_SECRETSHARING_DecryptRequestMessage *msg;
+  size_t share_size;
+
+  s->decrypt_cb = decrypt_cb;
+  s->decrypt_cls = decrypt_cb_cls;
+  s->mq = GNUNET_CLIENT_connect (cfg,
+                                 "secretsharing",
+                                 mq_handlers,
+                                 &handle_decrypt_client_error,
+                                 s);
+  if (NULL == s->mq)
+  {
+    GNUNET_free (s);
+    return NULL;
+  }
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_SECRETSHARING_share_write (share, NULL, 0,
+                                                   &share_size));
+
+  ev = GNUNET_MQ_msg_extra (msg,
+                            share_size,
+                            GNUNET_MESSAGE_TYPE_SECRETSHARING_CLIENT_DECRYPT);
+
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_SECRETSHARING_share_write (share,
+                                                   &msg[1],
+                                                   share_size,
+                                                   NULL));
+
+  msg->start = GNUNET_TIME_absolute_hton (start);
+  msg->deadline = GNUNET_TIME_absolute_hton (deadline);
+  msg->ciphertext = *ciphertext;
+
+  GNUNET_MQ_send (s->mq, ev);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "decrypt session created\n");
+  return s;
+}
+
+
+int
+GNUNET_SECRETSHARING_plaintext_generate_i (struct
+                                           GNUNET_SECRETSHARING_Plaintext *
+                                           plaintext,
+                                           int64_t exponent)
+{
+  int negative;
+  gcry_mpi_t x;
+
+  ensure_elgamal_initialized ();
+
+  GNUNET_assert (NULL != (x = gcry_mpi_new (0)));
+
+  negative = GNUNET_NO;
+  if (exponent < 0)
+  {
+    negative = GNUNET_YES;
+    exponent = -exponent;
+  }
+
+  gcry_mpi_set_ui (x, exponent);
+
+  gcry_mpi_powm (x, elgamal_g, x, elgamal_p);
+
+  if (GNUNET_YES == negative)
+  {
+    int res;
+    res = gcry_mpi_invm (x, x, elgamal_p);
+    if (0 == res)
+      return GNUNET_SYSERR;
+  }
+
+  GNUNET_CRYPTO_mpi_print_unsigned (plaintext,
+                                    sizeof(struct
+                                           GNUNET_SECRETSHARING_Plaintext),
+                                    x);
+
+  return GNUNET_OK;
+}
+
+
+int
+GNUNET_SECRETSHARING_encrypt (const struct
+                              GNUNET_SECRETSHARING_PublicKey *public_key,
+                              const struct
+                              GNUNET_SECRETSHARING_Plaintext *plaintext,
+                              struct GNUNET_SECRETSHARING_Ciphertext *
+                              result_ciphertext)
+{
+  /* pubkey */
+  gcry_mpi_t h;
+  /* nonce */
+  gcry_mpi_t y;
+  /* plaintext message */
+  gcry_mpi_t m;
+  /* temp value */
+  gcry_mpi_t tmp;
+
+  ensure_elgamal_initialized ();
+
+  GNUNET_assert (NULL != (h = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (y = gcry_mpi_new (0)));
+  GNUNET_assert (NULL != (tmp = gcry_mpi_new (0)));
+
+  GNUNET_CRYPTO_mpi_scan_unsigned (&h, public_key, sizeof *public_key);
+  GNUNET_CRYPTO_mpi_scan_unsigned (&m, plaintext, sizeof *plaintext);
+
+  // Randomize y such that 0 < y < elgamal_q.
+  // The '- 1' is necessary as bitlength(q) = bitlength(p) - 1.
+  do
+  {
+    gcry_mpi_randomize (y, GNUNET_SECRETSHARING_ELGAMAL_BITS - 1,
+                        GCRY_WEAK_RANDOM);
+  }
+  while ((gcry_mpi_cmp_ui (y, 0) == 0) || (gcry_mpi_cmp (y, elgamal_q) >= 0));
+
+  // tmp <- g^y
+  gcry_mpi_powm (tmp, elgamal_g, y, elgamal_p);
+  // write tmp to c1
+  GNUNET_CRYPTO_mpi_print_unsigned (&result_ciphertext->c1_bits,
+                                    GNUNET_SECRETSHARING_ELGAMAL_BITS / 8, tmp);
+
+  // tmp <- h^y
+  gcry_mpi_powm (tmp, h, y, elgamal_p);
+  // tmp <- tmp * m
+  gcry_mpi_mulm (tmp, tmp, m, elgamal_p);
+  // write tmp to c2
+  GNUNET_CRYPTO_mpi_print_unsigned (&result_ciphertext->c2_bits,
+                                    GNUNET_SECRETSHARING_ELGAMAL_BITS / 8, tmp);
+
+  return GNUNET_OK;
+}
+
+
+/**
+ * Cancel a decryption.
+ *
+ * The decrypt_cb is not called anymore, but the calling
+ * peer may already have irrevocably contributed its share for the decryption of the value.
+ *
+ * @param dh to cancel
+ */
+void
+GNUNET_SECRETSHARING_decrypt_cancel (struct
+                                     GNUNET_SECRETSHARING_DecryptionHandle *dh)
+{
+  GNUNET_MQ_destroy (dh->mq);
+  dh->mq = NULL;
+  GNUNET_free (dh);
+}
+
+
+/* end of secretsharing_api.c */
diff --git a/src/contrib/service/secretsharing/secretsharing_common.c b/src/contrib/service/secretsharing/secretsharing_common.c
new file mode 100644
index 000000000..44b96b1c8
--- /dev/null
+++ b/src/contrib/service/secretsharing/secretsharing_common.c
@@ -0,0 +1,159 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2014 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
+ */
+
+#include "platform.h"
+#include "secretsharing.h"
+
+/**
+ * Read a share from its binary representation.
+ *
+ * @param data Binary representation of the share.
+ * @param len Length of @a data.
+ * @param[out] readlen Number of bytes read,
+ *             ignored if NULL.
+ * @return The share, or NULL on error.
+ */
+struct GNUNET_SECRETSHARING_Share *
+GNUNET_SECRETSHARING_share_read (const void *data,
+                                 size_t len,
+                                 size_t *readlen)
+{
+  struct GNUNET_SECRETSHARING_Share *share;
+  const struct GNUNET_SECRETSHARING_ShareHeaderNBO *sh = data;
+  const char *p;
+  size_t n;
+  uint16_t payload_size;
+
+  payload_size = ntohs (sh->num_peers)
+                 * (sizeof(uint16_t) + sizeof(struct
+                                              GNUNET_SECRETSHARING_FieldElement)
+                    + sizeof(struct GNUNET_PeerIdentity));
+
+  if (NULL != readlen)
+    *readlen = payload_size + sizeof *sh;
+
+  share = GNUNET_new (struct GNUNET_SECRETSHARING_Share);
+
+  share->threshold = ntohs (sh->threshold);
+  share->num_peers = ntohs (sh->num_peers);
+  share->my_peer = ntohs (sh->my_peer);
+
+  share->my_share = sh->my_share;
+  share->public_key = sh->public_key;
+
+  p = (const char *) &sh[1];
+
+  n = share->num_peers * sizeof(struct GNUNET_PeerIdentity);
+  share->peers = GNUNET_new_array (share->num_peers,
+                                   struct GNUNET_PeerIdentity);
+  GNUNET_memcpy (share->peers, p, n);
+  p += n;
+
+  n = share->num_peers * sizeof(struct GNUNET_SECRETSHARING_FieldElement);
+  share->sigmas = GNUNET_new_array (share->num_peers,
+                                    struct GNUNET_SECRETSHARING_FieldElement);
+  GNUNET_memcpy (share->sigmas, p, n);
+  p += n;
+
+  n = share->num_peers * sizeof(uint16_t);
+  share->original_indices = GNUNET_new_array (share->num_peers,
+                                              uint16_t);
+  GNUNET_memcpy (share->original_indices, p, n);
+
+  return share;
+}
+
+
+/**
+ * Convert a share to its binary representation.
+ * Can be called with a NULL @a buf to get the size of the share.
+ *
+ * @param share Share to write.
+ * @param buf Buffer to write to.
+ * @param buflen Number of writable bytes in @a buf.
+ * @param[out] writelen Pointer to store number of bytes written,
+ *             ignored if NULL.
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure.
+ */
+int
+GNUNET_SECRETSHARING_share_write (const struct
+                                  GNUNET_SECRETSHARING_Share *share,
+                                  void *buf, size_t buflen, size_t *writelen)
+{
+  uint16_t payload_size;
+  struct GNUNET_SECRETSHARING_ShareHeaderNBO *sh;
+  char *p;
+  int n;
+
+  payload_size = share->num_peers
+                 * (sizeof(uint16_t) + sizeof(struct
+                                              GNUNET_SECRETSHARING_FieldElement)
+                    + sizeof(struct GNUNET_PeerIdentity));
+
+  if (NULL != writelen)
+    *writelen = payload_size + sizeof(struct
+                                      GNUNET_SECRETSHARING_ShareHeaderNBO);
+
+  /* just a query for the writelen */
+  if (buf == NULL)
+    return GNUNET_OK;
+
+  /* wrong buffer size */
+  if (buflen < payload_size + sizeof(struct
+                                     GNUNET_SECRETSHARING_ShareHeaderNBO))
+    return GNUNET_SYSERR;
+
+  sh = buf;
+
+  sh->threshold = htons (share->threshold);
+  sh->num_peers = htons (share->num_peers);
+  sh->my_peer = htons (share->my_peer);
+
+  sh->my_share = share->my_share;
+  sh->public_key = share->public_key;
+
+  p = (void *) &sh[1];
+
+  n = share->num_peers * sizeof(struct GNUNET_PeerIdentity);
+  GNUNET_memcpy (p, share->peers, n);
+  p += n;
+
+  n = share->num_peers * sizeof(struct GNUNET_SECRETSHARING_FieldElement);
+  GNUNET_memcpy (p, share->sigmas, n);
+  p += n;
+
+  n = share->num_peers * sizeof(uint16_t);
+  GNUNET_memcpy (p, share->original_indices, n);
+
+  return GNUNET_OK;
+}
+
+
+void
+GNUNET_SECRETSHARING_share_destroy (struct GNUNET_SECRETSHARING_Share *share)
+{
+  GNUNET_free (share->original_indices);
+  share->original_indices = NULL;
+  GNUNET_free (share->sigmas);
+  share->sigmas = NULL;
+  GNUNET_free (share->peers);
+  share->peers = NULL;
+  GNUNET_free (share);
+}
diff --git a/src/contrib/service/secretsharing/secretsharing_protocol.h b/src/contrib/service/secretsharing/secretsharing_protocol.h
new file mode 100644
index 000000000..e6f3ba286
--- /dev/null
+++ b/src/contrib/service/secretsharing/secretsharing_protocol.h
@@ -0,0 +1,147 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2012 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+
+/**
+ * @file secretsharing/secretsharing_protocol.h
+ * @brief p2p message definitions for secretsharing
+ * @author Florian Dold
+ */
+
+#ifndef GNUNET_SECRETSHARING_PROTOCOL_H
+#define GNUNET_SECRETSHARING_PROTOCOL_H
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_protocols.h"
+#include "secretsharing.h"
+
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+
+/**
+ * Consensus element data used in the first round of key generation.
+ */
+struct GNUNET_SECRETSHARING_KeygenCommitData
+{
+  /**
+   * Signature over the rest of the message.
+   */
+  struct GNUNET_CRYPTO_EddsaSignature signature;
+  /**
+   * Signature purpose for signing the keygen commit data.
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+  /**
+   * Peer that inserts this element.
+   */
+  struct GNUNET_PeerIdentity peer;
+  /**
+   * Ephemeral paillier public key used by 'peer' for
+   * this session.
+   */
+  struct GNUNET_CRYPTO_PaillierPublicKey pubkey;
+  /**
+   * Commitment of 'peer' to its presecret.
+   */
+  struct GNUNET_HashCode commitment GNUNET_PACKED;
+};
+
+
+struct GNUNET_SECRETSHARING_KeygenRevealData
+{
+  /**
+   * Signature over rest of the message.
+   */
+  struct GNUNET_CRYPTO_EddsaSignature signature;
+  /*
+   * Signature purpose for signing the keygen commit data.
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+  /**
+   * Peer that inserts this element.
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /* values follow */
+};
+
+
+/**
+ * Data of then element put in consensus
+ * for decrypting a value.
+ */
+struct GNUNET_SECRETSHARING_DecryptData
+{
+  /*
+   * Signature over rest of the message.
+   */
+  struct GNUNET_CRYPTO_EddsaSignature signature;
+  /*
+   * Signature purpose for signing the keygen commit data.
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+  /**
+   * Ciphertext we want to decrypt.
+   */
+  struct GNUNET_SECRETSHARING_Ciphertext ciphertext;
+  /**
+   * Peer that inserts this element.
+   */
+  struct GNUNET_PeerIdentity peer;
+  /**
+   * Partial decryption, computed as \f$c_1^{s_i}\f$
+   */
+  struct GNUNET_SECRETSHARING_FieldElement partial_decryption;
+  /**
+   * Commitment for the non-interactive zero knowledge proof.
+   * \f$g^\beta\f$, with \f$\beta < q\f$
+   */
+  struct GNUNET_SECRETSHARING_FieldElement nizk_commit1;
+  /**
+   * Commitment for the non-interactive zero knowledge proof.
+   * \f$c_1^\beta\f$, with \f$\beta < q\f$
+   */
+  struct GNUNET_SECRETSHARING_FieldElement nizk_commit2;
+  /**
+   * Response to the challenge computed from the protocol transcript.
+   * \f$r = \beta + challenge \cdot share_i\f$
+   */
+  struct GNUNET_SECRETSHARING_FieldElement nizk_response;
+};
+
+
+struct GNUNET_SECRETSHARING_FairEncryption
+{
+  struct GNUNET_CRYPTO_PaillierCiphertext c;
+  /**
+   * h = g^x, where x is the fairly encrypted secret.
+   */
+  char h[GNUNET_SECRETSHARING_ELGAMAL_BITS / 8];
+  char t1[GNUNET_SECRETSHARING_ELGAMAL_BITS / 8];
+  char t2[GNUNET_CRYPTO_PAILLIER_BITS * 2 / 8];
+  char z[GNUNET_SECRETSHARING_ELGAMAL_BITS / 8];
+  char w[GNUNET_CRYPTO_PAILLIER_BITS / 8];
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+#endif
diff --git a/src/contrib/service/secretsharing/test_secretsharing.conf b/src/contrib/service/secretsharing/test_secretsharing.conf
new file mode 100644
index 000000000..9cbe3ebb1
--- /dev/null
+++ b/src/contrib/service/secretsharing/test_secretsharing.conf
@@ -0,0 +1,40 @@
+[secretsharing]
+START_ON_DEMAND = YES
+#PREFIX = valgrind --leak-check=full
+OPTIONS = -LINFO
+
+[consensus]
+START_ON_DEMAND = YES
+
+[transport]
+OPTIONS = -LERROR
+PLUGINS = unix
+
+[set]
+OPTIONS = -L INFO
+START_ON_DEMAND = YES
+#PREFIX = valgrind --leak-check=full
+
+[testbed]
+OVERLAY_TOPOLOGY = CLIQUE
+
+[hostlist]
+SERVERS =
+
+[nat]
+# Use addresses from the local network interfaces (including loopback, but also others)
+USE_LOCALADDR = YES
+
+# Disable IPv6 support
+DISABLEV6 = NO
+
+# Do we use addresses from localhost address ranges? (::1, 127.0.0.0/8)
+RETURN_LOCAL_ADDRESSES = YES
+
+[nse]
+START_ON_DEMAND = NO
+
+
+[rps]
+START_ON_DEMAND = NO
+IMMEDIATE_START = NO
diff --git a/src/contrib/service/secretsharing/test_secretsharing_api.c b/src/contrib/service/secretsharing/test_secretsharing_api.c
new file mode 100644
index 000000000..470bfddf4
--- /dev/null
+++ b/src/contrib/service/secretsharing/test_secretsharing_api.c
@@ -0,0 +1,103 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2014 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 secretsharing/test_secretsharing_api.c
+ * @brief testcase for the secretsharing api
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_secretsharing_service.h"
+
+
+static int success;
+
+static struct GNUNET_SECRETSHARING_Session *keygen;
+
+
+static void
+secret_ready_cb (void *cls,
+                 struct GNUNET_SECRETSHARING_Share *my_share,
+                 struct GNUNET_SECRETSHARING_PublicKey *public_key,
+                 unsigned int num_ready_peers,
+                 const struct GNUNET_PeerIdentity *ready_peers)
+{
+  keygen = NULL;
+  if (num_ready_peers == 1)
+    success = 1;
+  // FIXME: check that our share is valid, which we can do as there's only
+  // one peer.
+  GNUNET_SECRETSHARING_share_destroy (my_share);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "secret ready, shutting down\n");
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+static void
+handle_shutdown (void *cls)
+{
+  if (NULL != keygen)
+  {
+    GNUNET_SECRETSHARING_session_destroy (keygen);
+    keygen = NULL;
+  }
+}
+
+
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
+{
+  struct GNUNET_HashCode session_id;
+  struct GNUNET_TIME_Absolute start;
+  struct GNUNET_TIME_Absolute deadline;
+
+  GNUNET_SCHEDULER_add_shutdown (&handle_shutdown, NULL);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "testing secretsharing api\n");
+
+  GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &session_id);
+
+  start = GNUNET_TIME_absolute_get ();
+  deadline = GNUNET_TIME_absolute_add (start, GNUNET_TIME_UNIT_SECONDS);
+
+  keygen = GNUNET_SECRETSHARING_create_session (cfg,
+                                                0, NULL, /* only the local peer */
+                                                &session_id,
+                                                start, deadline,
+                                                1,
+                                                secret_ready_cb, NULL);
+}
+
+
+int
+main (int argc, char **argv)
+{
+  int ret;
+
+  ret = GNUNET_TESTING_peer_run ("test_secretsharing_api",
+                                 "test_secretsharing.conf",
+                                 &run, NULL);
+  if (0 != ret)
+    return ret;
+  return (GNUNET_YES == success) ? 0 : 1;
+}
diff --git a/src/contrib/service/set/.gitignore b/src/contrib/service/set/.gitignore
new file mode 100644
index 000000000..f1c958639
--- /dev/null
+++ b/src/contrib/service/set/.gitignore
@@ -0,0 +1,7 @@
+gnunet-set-profiler
+gnunet-service-set
+gnunet-set-ibf-profiler
+test_set_api
+test_set_intersection_result_full
+test_set_union_copy
+test_set_union_result_symmetric
diff --git a/src/contrib/service/set/Makefile.am b/src/contrib/service/set/Makefile.am
new file mode 100644
index 000000000..d8e19e6d4
--- /dev/null
+++ b/src/contrib/service/set/Makefile.am
@@ -0,0 +1,111 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+plugindir = $(libdir)/gnunet
+
+pkgcfg_DATA = \
+  set.conf
+
+if USE_COVERAGE
+  AM_CFLAGS = -fprofile-arcs -ftest-coverage
+endif
+
+noinst_PROGRAMS = \
+ gnunet-set-ibf-profiler
+
+libexec_PROGRAMS = \
+ gnunet-service-set
+
+lib_LTLIBRARIES = \
+  libgnunetset.la
+
+gnunet_set_ibf_profiler_SOURCES = \
+ gnunet-set-ibf-profiler.c \
+ ibf.c
+gnunet_set_ibf_profiler_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(GN_LIBINTL)
+
+gnunet_service_set_SOURCES = \
+ gnunet-service-set.c gnunet-service-set.h \
+ gnunet-service-set_union.c gnunet-service-set_union.h \
+ gnunet-service-set_intersection.c gnunet-service-set_intersection.h \
+ ibf.c ibf.h \
+ gnunet-service-set_union_strata_estimator.c gnunet-service-set_union_strata_estimator.h \
+ gnunet-service-set_protocol.h
+gnunet_service_set_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(top_builddir)/src/service/core/libgnunetcore.la \
+  $(top_builddir)/src/service/cadet/libgnunetcadet.la \
+  $(top_builddir)/src/lib/block/libgnunetblock.la \
+  libgnunetset.la \
+  $(GN_LIBINTL)
+
+libgnunetset_la_SOURCES = \
+  set_api.c set.h
+libgnunetset_la_LIBADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunetset_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)
+
+check_PROGRAMS = \
+ # test_set_api \
+ # test_set_union_result_symmetric \
+ # test_set_intersection_result_full \
+ test_set_union_copy
+
+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_set_api_SOURCES = \
+ test_set_api.c
+test_set_api_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/service/testing/libgnunettesting.la \
+  libgnunetset.la
+
+test_set_union_result_symmetric_SOURCES = \
+ test_set_union_result_symmetric.c
+test_set_union_result_symmetric_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/service/testing/libgnunettesting.la \
+  libgnunetset.la
+
+test_set_intersection_result_full_SOURCES = \
+ test_set_intersection_result_full.c
+test_set_intersection_result_full_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/service/testing/libgnunettesting.la \
+  libgnunetset.la
+
+test_set_union_copy_SOURCES = \
+ test_set_union_copy.c
+test_set_union_copy_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(top_builddir)/src/service/testing/libgnunettesting.la \
+  libgnunetset.la
+
+plugin_LTLIBRARIES = \
+  libgnunet_plugin_block_set_test.la
+
+libgnunet_plugin_block_set_test_la_SOURCES = \
+  plugin_block_set_test.c
+libgnunet_plugin_block_set_test_la_LIBADD = \
+  $(top_builddir)/src/lib/block/libgnunetblock.la \
+  $(top_builddir)/src/lib/block/libgnunetblockgroup.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunet_plugin_block_set_test_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
+
+
+EXTRA_DIST = \
+  test_set.conf
diff --git a/src/contrib/service/set/gnunet-service-set.c b/src/contrib/service/set/gnunet-service-set.c
new file mode 100644
index 000000000..7c522ec34
--- /dev/null
+++ b/src/contrib/service/set/gnunet-service-set.c
@@ -0,0 +1,1983 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2013-2017 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file set/gnunet-service-set.c
+ * @brief two-peer set operations
+ * @author Florian Dold
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet-service-set.h"
+#include "gnunet-service-set_union.h"
+#include "gnunet-service-set_intersection.h"
+#include "gnunet-service-set_protocol.h"
+#include "gnunet_statistics_service.h"
+
+/**
+ * How long do we hold on to an incoming channel if there is
+ * no local listener before giving up?
+ */
+#define INCOMING_CHANNEL_TIMEOUT GNUNET_TIME_UNIT_MINUTES
+
+
+/**
+ * Lazy copy requests made by a client.
+ */
+struct LazyCopyRequest
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct LazyCopyRequest *prev;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct LazyCopyRequest *next;
+
+  /**
+   * Which set are we supposed to copy?
+   */
+  struct Set *source_set;
+
+  /**
+   * Cookie identifying the request.
+   */
+  uint32_t cookie;
+};
+
+
+/**
+ * A listener is inhabited by a client, and waits for evaluation
+ * requests from remote peers.
+ */
+struct Listener
+{
+  /**
+   * Listeners are held in a doubly linked list.
+   */
+  struct Listener *next;
+
+  /**
+   * Listeners are held in a doubly linked list.
+   */
+  struct Listener *prev;
+
+  /**
+   * Head of DLL of operations this listener is responsible for.
+   * Once the client has accepted/declined the operation, the
+   * operation is moved to the respective set's operation DLLS.
+   */
+  struct Operation *op_head;
+
+  /**
+   * Tail of DLL of operations this listener is responsible for.
+   * Once the client has accepted/declined the operation, the
+   * operation is moved to the respective set's operation DLLS.
+   */
+  struct Operation *op_tail;
+
+  /**
+   * Client that owns the listener.
+   * Only one client may own a listener.
+   */
+  struct ClientState *cs;
+
+  /**
+   * The port we are listening on with CADET.
+   */
+  struct GNUNET_CADET_Port *open_port;
+
+  /**
+   * Application ID for the operation, used to distinguish
+   * multiple operations of the same type with the same peer.
+   */
+  struct GNUNET_HashCode app_id;
+
+  /**
+   * The type of the operation.
+   */
+  enum GNUNET_SET_OperationType operation;
+};
+
+
+/**
+ * Handle to the cadet service, used to listen for and connect to
+ * remote peers.
+ */
+static struct GNUNET_CADET_Handle *cadet;
+
+/**
+ * DLL of lazy copy requests by this client.
+ */
+static struct LazyCopyRequest *lazy_copy_head;
+
+/**
+ * DLL of lazy copy requests by this client.
+ */
+static struct LazyCopyRequest *lazy_copy_tail;
+
+/**
+ * Generator for unique cookie we set per lazy copy request.
+ */
+static uint32_t lazy_copy_cookie;
+
+/**
+ * Statistics handle.
+ */
+struct GNUNET_STATISTICS_Handle *_GSS_statistics;
+
+/**
+ * Listeners are held in a doubly linked list.
+ */
+static struct Listener *listener_head;
+
+/**
+ * Listeners are held in a doubly linked list.
+ */
+static struct Listener *listener_tail;
+
+/**
+ * Number of active clients.
+ */
+static unsigned int num_clients;
+
+/**
+ * Are we in shutdown? if #GNUNET_YES and the number of clients
+ * drops to zero, disconnect from CADET.
+ */
+static int in_shutdown;
+
+/**
+ * Counter for allocating unique IDs for clients, used to identify
+ * incoming operation requests from remote peers, that the client can
+ * choose to accept or refuse.  0 must not be used (reserved for
+ * uninitialized).
+ */
+static uint32_t suggest_id;
+
+
+/**
+ * Get the incoming socket associated with the given id.
+ *
+ * @param id id to look for
+ * @return the incoming socket associated with the id,
+ *         or NULL if there is none
+ */
+static struct Operation *
+get_incoming (uint32_t id)
+{
+  for (struct Listener *listener = listener_head; NULL != listener;
+       listener = listener->next)
+  {
+    for (struct Operation *op = listener->op_head; NULL != op; op = op->next)
+      if (op->suggest_id == id)
+        return op;
+  }
+  return NULL;
+}
+
+
+/**
+ * Destroy an incoming request from a remote peer
+ *
+ * @param op remote request to destroy
+ */
+static void
+incoming_destroy (struct Operation *op)
+{
+  struct Listener *listener;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Destroying incoming operation %p\n",
+              op);
+  if (NULL != (listener = op->listener))
+  {
+    GNUNET_CONTAINER_DLL_remove (listener->op_head, listener->op_tail, op);
+    op->listener = NULL;
+  }
+  if (NULL != op->timeout_task)
+  {
+    GNUNET_SCHEDULER_cancel (op->timeout_task);
+    op->timeout_task = NULL;
+  }
+  _GSS_operation_destroy2 (op);
+}
+
+
+/**
+ * Context for the #garbage_collect_cb().
+ */
+struct GarbageContext
+{
+  /**
+   * Map for which we are garbage collecting removed elements.
+   */
+  struct GNUNET_CONTAINER_MultiHashMap *map;
+
+  /**
+   * Lowest generation for which an operation is still pending.
+   */
+  unsigned int min_op_generation;
+
+  /**
+   * Largest generation for which an operation is still pending.
+   */
+  unsigned int max_op_generation;
+};
+
+
+/**
+ * Function invoked to check if an element can be removed from
+ * the set's history because it is no longer needed.
+ *
+ * @param cls the `struct GarbageContext *`
+ * @param key key of the element in the map
+ * @param value the `struct ElementEntry *`
+ * @return #GNUNET_OK (continue to iterate)
+ */
+static int
+garbage_collect_cb (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  // struct GarbageContext *gc = cls;
+  // struct ElementEntry *ee = value;
+
+  // if (GNUNET_YES != ee->removed)
+  //  return GNUNET_OK;
+  // if ( (gc->max_op_generation < ee->generation_added) ||
+  //     (ee->generation_removed > gc->min_op_generation) )
+  // {
+  //  GNUNET_assert (GNUNET_YES ==
+  //                 GNUNET_CONTAINER_multihashmap_remove (gc->map,
+  //                                                       key,
+  //                                                       ee));
+  //  GNUNET_free (ee);
+  // }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Collect and destroy elements that are not needed anymore, because
+ * their lifetime (as determined by their generation) does not overlap
+ * with any active set operation.
+ *
+ * @param set set to garbage collect
+ */
+static void
+collect_generation_garbage (struct Set *set)
+{
+  struct GarbageContext gc;
+
+  gc.min_op_generation = UINT_MAX;
+  gc.max_op_generation = 0;
+  for (struct Operation *op = set->ops_head; NULL != op; op = op->next)
+  {
+    gc.min_op_generation =
+      GNUNET_MIN (gc.min_op_generation, op->generation_created);
+    gc.max_op_generation =
+      GNUNET_MAX (gc.max_op_generation, op->generation_created);
+  }
+  gc.map = set->content->elements;
+  GNUNET_CONTAINER_multihashmap_iterate (set->content->elements,
+                                         &garbage_collect_cb,
+                                         &gc);
+}
+
+
+/**
+ * Is @a generation in the range of exclusions?
+ *
+ * @param generation generation to query
+ * @param excluded array of generations where the element is excluded
+ * @param excluded_size length of the @a excluded array
+ * @return #GNUNET_YES if @a generation is in any of the ranges
+ */
+static int
+is_excluded_generation (unsigned int generation,
+                        struct GenerationRange *excluded,
+                        unsigned int excluded_size)
+{
+  for (unsigned int i = 0; i < excluded_size; i++)
+    if ((generation >= excluded[i].start) && (generation < excluded[i].end))
+      return GNUNET_YES;
+  return GNUNET_NO;
+}
+
+
+/**
+ * Is element @a ee part of the set during @a query_generation?
+ *
+ * @param ee element to test
+ * @param query_generation generation to query
+ * @param excluded array of generations where the element is excluded
+ * @param excluded_size length of the @a excluded array
+ * @return #GNUNET_YES if the element is in the set, #GNUNET_NO if not
+ */
+static int
+is_element_of_generation (struct ElementEntry *ee,
+                          unsigned int query_generation,
+                          struct GenerationRange *excluded,
+                          unsigned int excluded_size)
+{
+  struct MutationEvent *mut;
+  int is_present;
+
+  GNUNET_assert (NULL != ee->mutations);
+  if (GNUNET_YES ==
+      is_excluded_generation (query_generation, excluded, excluded_size))
+  {
+    GNUNET_break (0);
+    return GNUNET_NO;
+  }
+
+  is_present = GNUNET_NO;
+
+  /* Could be made faster with binary search, but lists
+     are small, so why bother. */
+  for (unsigned int i = 0; i < ee->mutations_size; i++)
+  {
+    mut = &ee->mutations[i];
+
+    if (mut->generation > query_generation)
+    {
+      /* The mutation doesn't apply to our generation
+         anymore.  We can'b break here, since mutations aren't
+         sorted by generation. */
+      continue;
+    }
+
+    if (GNUNET_YES ==
+        is_excluded_generation (mut->generation, excluded, excluded_size))
+    {
+      /* The generation is excluded (because it belongs to another
+         fork via a lazy copy) and thus mutations aren't considered
+         for membership testing. */
+      continue;
+    }
+
+    /* This would be an inconsistency in how we manage mutations. */
+    if ((GNUNET_YES == is_present) && (GNUNET_YES == mut->added))
+      GNUNET_assert (0);
+    /* Likewise. */
+    if ((GNUNET_NO == is_present) && (GNUNET_NO == mut->added))
+      GNUNET_assert (0);
+
+    is_present = mut->added;
+  }
+
+  return is_present;
+}
+
+
+/**
+ * Is element @a ee part of the set used by @a op?
+ *
+ * @param ee element to test
+ * @param op operation the defines the set and its generation
+ * @return #GNUNET_YES if the element is in the set, #GNUNET_NO if not
+ */
+int
+_GSS_is_element_of_operation (struct ElementEntry *ee, struct Operation *op)
+{
+  return is_element_of_generation (ee,
+                                   op->generation_created,
+                                   op->set->excluded_generations,
+                                   op->set->excluded_generations_size);
+}
+
+
+/**
+ * Destroy the given operation.  Used for any operation where both
+ * peers were known and that thus actually had a vt and channel.  Must
+ * not be used for operations where 'listener' is still set and we do
+ * not know the other peer.
+ *
+ * Call the implementation-specific cancel function of the operation.
+ * Disconnects from the remote peer.  Does not disconnect the client,
+ * as there may be multiple operations per set.
+ *
+ * @param op operation to destroy
+ * @param gc #GNUNET_YES to perform garbage collection on the set
+ */
+void
+_GSS_operation_destroy (struct Operation *op, int gc)
+{
+  struct Set *set = op->set;
+  struct GNUNET_CADET_Channel *channel;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Destroying operation %p\n", op);
+  GNUNET_assert (NULL == op->listener);
+  if (NULL != op->state)
+  {
+    set->vt->cancel (op);
+    op->state = NULL;
+  }
+  if (NULL != set)
+  {
+    GNUNET_CONTAINER_DLL_remove (set->ops_head, set->ops_tail, op);
+    op->set = NULL;
+  }
+  if (NULL != op->context_msg)
+  {
+    GNUNET_free (op->context_msg);
+    op->context_msg = NULL;
+  }
+  if (NULL != (channel = op->channel))
+  {
+    /* This will free op; called conditionally as this helper function
+       is also called from within the channel disconnect handler. */
+    op->channel = NULL;
+    GNUNET_CADET_channel_destroy (channel);
+  }
+  if ((NULL != set) && (GNUNET_YES == gc))
+    collect_generation_garbage (set);
+  /* We rely on the channel end handler to free 'op'. When 'op->channel' was NULL,
+   * there was a channel end handler that will free 'op' on the call stack. */
+}
+
+
+/**
+ * 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 `struct ClientState`
+ */
+static void *
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *c,
+                   struct GNUNET_MQ_Handle *mq)
+{
+  struct ClientState *cs;
+
+  num_clients++;
+  cs = GNUNET_new (struct ClientState);
+  cs->client = c;
+  cs->mq = mq;
+  return cs;
+}
+
+
+/**
+ * Iterator over hash map entries to free element entries.
+ *
+ * @param cls closure
+ * @param key current key code
+ * @param value a `struct ElementEntry *` to be free'd
+ * @return #GNUNET_YES (continue to iterate)
+ */
+static int
+destroy_elements_iterator (void *cls,
+                           const struct GNUNET_HashCode *key,
+                           void *value)
+{
+  struct ElementEntry *ee = value;
+
+  GNUNET_free (ee->mutations);
+  GNUNET_free (ee);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Clean up after a client has disconnected
+ *
+ * @param cls closure, unused
+ * @param client the client to clean up after
+ * @param internal_cls the `struct ClientState`
+ */
+static void
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *internal_cls)
+{
+  struct ClientState *cs = internal_cls;
+  struct Operation *op;
+  struct Listener *listener;
+  struct Set *set;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client disconnected, cleaning up\n");
+  if (NULL != (set = cs->set))
+  {
+    struct SetContent *content = set->content;
+    struct PendingMutation *pm;
+    struct PendingMutation *pm_current;
+    struct LazyCopyRequest *lcr;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Destroying client's set\n");
+    /* Destroy pending set operations */
+    while (NULL != set->ops_head)
+      _GSS_operation_destroy (set->ops_head, GNUNET_NO);
+
+    /* Destroy operation-specific state */
+    GNUNET_assert (NULL != set->state);
+    set->vt->destroy_set (set->state);
+    set->state = NULL;
+
+    /* Clean up ongoing iterations */
+    if (NULL != set->iter)
+    {
+      GNUNET_CONTAINER_multihashmap_iterator_destroy (set->iter);
+      set->iter = NULL;
+      set->iteration_id++;
+    }
+
+    /* discard any pending mutations that reference this set */
+    pm = content->pending_mutations_head;
+    while (NULL != pm)
+    {
+      pm_current = pm;
+      pm = pm->next;
+      if (pm_current->set == set)
+      {
+        GNUNET_CONTAINER_DLL_remove (content->pending_mutations_head,
+                                     content->pending_mutations_tail,
+                                     pm_current);
+        GNUNET_free (pm_current);
+      }
+    }
+
+    /* free set content (or at least decrement RC) */
+    set->content = NULL;
+    GNUNET_assert (0 != content->refcount);
+    content->refcount--;
+    if (0 == content->refcount)
+    {
+      GNUNET_assert (NULL != content->elements);
+      GNUNET_CONTAINER_multihashmap_iterate (content->elements,
+                                             &destroy_elements_iterator,
+                                             NULL);
+      GNUNET_CONTAINER_multihashmap_destroy (content->elements);
+      content->elements = NULL;
+      GNUNET_free (content);
+    }
+    GNUNET_free (set->excluded_generations);
+    set->excluded_generations = NULL;
+
+    /* remove set from pending copy requests */
+    lcr = lazy_copy_head;
+    while (NULL != lcr)
+    {
+      struct LazyCopyRequest *lcr_current = lcr;
+
+      lcr = lcr->next;
+      if (lcr_current->source_set == set)
+      {
+        GNUNET_CONTAINER_DLL_remove (lazy_copy_head,
+                                     lazy_copy_tail,
+                                     lcr_current);
+        GNUNET_free (lcr_current);
+      }
+    }
+    GNUNET_free (set);
+  }
+
+  if (NULL != (listener = cs->listener))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Destroying client's listener\n");
+    GNUNET_CADET_close_port (listener->open_port);
+    listener->open_port = NULL;
+    while (NULL != (op = listener->op_head))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Destroying incoming operation `%u' from peer `%s'\n",
+                  (unsigned int) op->client_request_id,
+                  GNUNET_i2s (&op->peer));
+      incoming_destroy (op);
+    }
+    GNUNET_CONTAINER_DLL_remove (listener_head, listener_tail, listener);
+    GNUNET_free (listener);
+  }
+  GNUNET_free (cs);
+  num_clients--;
+  if ((GNUNET_YES == in_shutdown) && (0 == num_clients))
+  {
+    if (NULL != cadet)
+    {
+      GNUNET_CADET_disconnect (cadet);
+      cadet = NULL;
+    }
+  }
+}
+
+
+/**
+ * Check a request for a set operation from another peer.
+ *
+ * @param cls the operation state
+ * @param msg the received message
+ * @return #GNUNET_OK if the channel should be kept alive,
+ *         #GNUNET_SYSERR to destroy the channel
+ */
+static int
+check_incoming_msg (void *cls, const struct OperationRequestMessage *msg)
+{
+  struct Operation *op = cls;
+  struct Listener *listener = op->listener;
+  const struct GNUNET_MessageHeader *nested_context;
+
+  /* double operation request */
+  if (0 != op->suggest_id)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  /* This should be equivalent to the previous condition, but can't hurt to check twice */
+  if (NULL == op->listener)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  if (listener->operation !=
+      (enum GNUNET_SET_OperationType) ntohl (msg->operation))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  nested_context = GNUNET_MQ_extract_nested_mh (msg);
+  if ((NULL != nested_context) &&
+      (ntohs (nested_context->size) > GNUNET_SET_CONTEXT_MESSAGE_MAX_SIZE))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle a request for a set operation from another peer.  Checks if we
+ * have a listener waiting for such a request (and in that case initiates
+ * asking the listener about accepting the connection). If no listener
+ * is waiting, we queue the operation request in hope that a listener
+ * shows up soon (before timeout).
+ *
+ * This msg is expected as the first and only msg handled through the
+ * non-operation bound virtual table, acceptance of this operation replaces
+ * our virtual table and subsequent msgs would be routed differently (as
+ * we then know what type of operation this is).
+ *
+ * @param cls the operation state
+ * @param msg the received message
+ * @return #GNUNET_OK if the channel should be kept alive,
+ *         #GNUNET_SYSERR to destroy the channel
+ */
+static void
+handle_incoming_msg (void *cls, const struct OperationRequestMessage *msg)
+{
+  struct Operation *op = cls;
+  struct Listener *listener = op->listener;
+  const struct GNUNET_MessageHeader *nested_context;
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_SET_RequestMessage *cmsg;
+
+  nested_context = GNUNET_MQ_extract_nested_mh (msg);
+  /* Make a copy of the nested_context (application-specific context
+     information that is opaque to set) so we can pass it to the
+     listener later on */
+  if (NULL != nested_context)
+    op->context_msg = GNUNET_copy_message (nested_context);
+  op->remote_element_count = ntohl (msg->element_count);
+  GNUNET_log (
+    GNUNET_ERROR_TYPE_DEBUG,
+    "Received P2P operation request (op %u, port %s) for active listener\n",
+    (uint32_t) ntohl (msg->operation),
+    GNUNET_h2s (&op->listener->app_id));
+  GNUNET_assert (0 == op->suggest_id);
+  if (0 == suggest_id)
+    suggest_id++;
+  op->suggest_id = suggest_id++;
+  GNUNET_assert (NULL != op->timeout_task);
+  GNUNET_SCHEDULER_cancel (op->timeout_task);
+  op->timeout_task = NULL;
+  env = GNUNET_MQ_msg_nested_mh (cmsg,
+                                 GNUNET_MESSAGE_TYPE_SET_REQUEST,
+                                 op->context_msg);
+  GNUNET_log (
+    GNUNET_ERROR_TYPE_DEBUG,
+    "Suggesting incoming request with accept id %u to listener %p of client %p\n",
+    op->suggest_id,
+    listener,
+    listener->cs);
+  cmsg->accept_id = htonl (op->suggest_id);
+  cmsg->peer_id = op->peer;
+  GNUNET_MQ_send (listener->cs->mq, env);
+  /* NOTE: GNUNET_CADET_receive_done() will be called in
+   #handle_client_accept() */
+}
+
+
+/**
+ * Add an element to @a set as specified by @a msg
+ *
+ * @param set set to manipulate
+ * @param msg message specifying the change
+ */
+static void
+execute_add (struct Set *set, const struct GNUNET_SET_ElementMessage *msg)
+{
+  struct GNUNET_SET_Element el;
+  struct ElementEntry *ee;
+  struct GNUNET_HashCode hash;
+
+  GNUNET_assert (GNUNET_MESSAGE_TYPE_SET_ADD == ntohs (msg->header.type));
+  el.size = ntohs (msg->header.size) - sizeof(*msg);
+  el.data = &msg[1];
+  el.element_type = ntohs (msg->element_type);
+  GNUNET_SET_element_hash (&el, &hash);
+  ee = GNUNET_CONTAINER_multihashmap_get (set->content->elements, &hash);
+  if (NULL == ee)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Client inserts element %s of size %u\n",
+                GNUNET_h2s (&hash),
+                el.size);
+    ee = GNUNET_malloc (el.size + sizeof(*ee));
+    ee->element.size = el.size;
+    GNUNET_memcpy (&ee[1], el.data, el.size);
+    ee->element.data = &ee[1];
+    ee->element.element_type = el.element_type;
+    ee->remote = GNUNET_NO;
+    ee->mutations = NULL;
+    ee->mutations_size = 0;
+    ee->element_hash = hash;
+    GNUNET_break (GNUNET_YES ==
+                  GNUNET_CONTAINER_multihashmap_put (
+                    set->content->elements,
+                    &ee->element_hash,
+                    ee,
+                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  }
+  else if (GNUNET_YES ==
+           is_element_of_generation (ee,
+                                     set->current_generation,
+                                     set->excluded_generations,
+                                     set->excluded_generations_size))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Client inserted element %s of size %u twice (ignored)\n",
+                GNUNET_h2s (&hash),
+                el.size);
+
+    /* same element inserted twice */
+    return;
+  }
+
+  {
+    struct MutationEvent mut = { .generation = set->current_generation,
+                                 .added = GNUNET_YES };
+    GNUNET_array_append (ee->mutations, ee->mutations_size, mut);
+  }
+  set->vt->add (set->state, ee);
+}
+
+
+/**
+ * Remove an element from @a set as specified by @a msg
+ *
+ * @param set set to manipulate
+ * @param msg message specifying the change
+ */
+static void
+execute_remove (struct Set *set, const struct GNUNET_SET_ElementMessage *msg)
+{
+  struct GNUNET_SET_Element el;
+  struct ElementEntry *ee;
+  struct GNUNET_HashCode hash;
+
+  GNUNET_assert (GNUNET_MESSAGE_TYPE_SET_REMOVE == ntohs (msg->header.type));
+  el.size = ntohs (msg->header.size) - sizeof(*msg);
+  el.data = &msg[1];
+  el.element_type = ntohs (msg->element_type);
+  GNUNET_SET_element_hash (&el, &hash);
+  ee = GNUNET_CONTAINER_multihashmap_get (set->content->elements, &hash);
+  if (NULL == ee)
+  {
+    /* Client tried to remove non-existing element. */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Client removes non-existing element of size %u\n",
+                el.size);
+    return;
+  }
+  if (GNUNET_NO == is_element_of_generation (ee,
+                                             set->current_generation,
+                                             set->excluded_generations,
+                                             set->excluded_generations_size))
+  {
+    /* Client tried to remove element twice */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Client removed element of size %u twice (ignored)\n",
+                el.size);
+    return;
+  }
+  else
+  {
+    struct MutationEvent mut = { .generation = set->current_generation,
+                                 .added = GNUNET_NO };
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Client removes element of size %u\n",
+                el.size);
+
+    GNUNET_array_append (ee->mutations, ee->mutations_size, mut);
+  }
+  set->vt->remove (set->state, ee);
+}
+
+
+/**
+ * Perform a mutation on a set as specified by the @a msg
+ *
+ * @param set the set to mutate
+ * @param msg specification of what to change
+ */
+static void
+execute_mutation (struct Set *set, const struct GNUNET_SET_ElementMessage *msg)
+{
+  switch (ntohs (msg->header.type))
+  {
+  case GNUNET_MESSAGE_TYPE_SET_ADD:
+    execute_add (set, msg);
+    break;
+
+  case GNUNET_MESSAGE_TYPE_SET_REMOVE:
+    execute_remove (set, msg);
+    break;
+
+  default:
+    GNUNET_break (0);
+  }
+}
+
+
+/**
+ * Execute mutations that were delayed on a set because of
+ * pending operations.
+ *
+ * @param set the set to execute mutations on
+ */
+static void
+execute_delayed_mutations (struct Set *set)
+{
+  struct PendingMutation *pm;
+
+  if (0 != set->content->iterator_count)
+    return; /* still cannot do this */
+  while (NULL != (pm = set->content->pending_mutations_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (set->content->pending_mutations_head,
+                                 set->content->pending_mutations_tail,
+                                 pm);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Executing pending mutation on %p.\n",
+                pm->set);
+    execute_mutation (pm->set, pm->msg);
+    GNUNET_free (pm->msg);
+    GNUNET_free (pm);
+  }
+}
+
+
+/**
+ * Send the next element of a set to the set's client.  The next element is given by
+ * the set's current hashmap iterator.  The set's iterator will be set to NULL if there
+ * are no more elements in the set.  The caller must ensure that the set's iterator is
+ * valid.
+ *
+ * The client will acknowledge each received element with a
+ * #GNUNET_MESSAGE_TYPE_SET_ITER_ACK message.  Our
+ * #handle_client_iter_ack() will then trigger the next transmission.
+ * Note that the #GNUNET_MESSAGE_TYPE_SET_ITER_DONE is not acknowledged.
+ *
+ * @param set set that should send its next element to its client
+ */
+static void
+send_client_element (struct Set *set)
+{
+  int ret;
+  struct ElementEntry *ee;
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_SET_IterResponseMessage *msg;
+
+  GNUNET_assert (NULL != set->iter);
+  do
+  {
+    ret = GNUNET_CONTAINER_multihashmap_iterator_next (set->iter,
+                                                       NULL,
+                                                       (const void **) &ee);
+    if (GNUNET_NO == ret)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Iteration on %p done.\n", set);
+      ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_ITER_DONE);
+      GNUNET_CONTAINER_multihashmap_iterator_destroy (set->iter);
+      set->iter = NULL;
+      set->iteration_id++;
+      GNUNET_assert (set->content->iterator_count > 0);
+      set->content->iterator_count--;
+      execute_delayed_mutations (set);
+      GNUNET_MQ_send (set->cs->mq, ev);
+      return;
+    }
+    GNUNET_assert (NULL != ee);
+  }
+  while (GNUNET_NO ==
+         is_element_of_generation (ee,
+                                   set->iter_generation,
+                                   set->excluded_generations,
+                                   set->excluded_generations_size));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending iteration element on %p.\n",
+              set);
+  ev = GNUNET_MQ_msg_extra (msg,
+                            ee->element.size,
+                            GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT);
+  GNUNET_memcpy (&msg[1], ee->element.data, ee->element.size);
+  msg->element_type = htons (ee->element.element_type);
+  msg->iteration_id = htons (set->iteration_id);
+  GNUNET_MQ_send (set->cs->mq, ev);
+}
+
+
+/**
+ * Called when a client wants to iterate the elements of a set.
+ * Checks if we have a set associated with the client and if we
+ * can right now start an iteration. If all checks out, starts
+ * sending the elements of the set to the client.
+ *
+ * @param cls client that sent the message
+ * @param m message sent by the client
+ */
+static void
+handle_client_iterate (void *cls, const struct GNUNET_MessageHeader *m)
+{
+  struct ClientState *cs = cls;
+  struct Set *set;
+
+  if (NULL == (set = cs->set))
+  {
+    /* attempt to iterate over a non existing set */
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  if (NULL != set->iter)
+  {
+    /* Only one concurrent iterate-action allowed per set */
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Iterating set %p in gen %u with %u content elements\n",
+              (void *) set,
+              set->current_generation,
+              GNUNET_CONTAINER_multihashmap_size (set->content->elements));
+  GNUNET_SERVICE_client_continue (cs->client);
+  set->content->iterator_count++;
+  set->iter =
+    GNUNET_CONTAINER_multihashmap_iterator_create (set->content->elements);
+  set->iter_generation = set->current_generation;
+  send_client_element (set);
+}
+
+
+/**
+ * Called when a client wants to create a new set.  This is typically
+ * the first request from a client, and includes the type of set
+ * operation to be performed.
+ *
+ * @param cls client that sent the message
+ * @param msg message sent by the client
+ */
+static void
+handle_client_create_set (void *cls, const struct GNUNET_SET_CreateMessage *msg)
+{
+  struct ClientState *cs = cls;
+  struct Set *set;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Client created new set (operation %u)\n",
+              (uint32_t) ntohl (msg->operation));
+  if (NULL != cs->set)
+  {
+    /* There can only be one set per client */
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  set = GNUNET_new (struct Set);
+  switch (ntohl (msg->operation))
+  {
+  case GNUNET_SET_OPERATION_INTERSECTION:
+    set->vt = _GSS_intersection_vt ();
+    break;
+
+  case GNUNET_SET_OPERATION_UNION:
+    set->vt = _GSS_union_vt ();
+    break;
+
+  default:
+    GNUNET_free (set);
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  set->operation = (enum GNUNET_SET_OperationType) ntohl (msg->operation);
+  set->state = set->vt->create ();
+  if (NULL == set->state)
+  {
+    /* initialization failed (i.e. out of memory) */
+    GNUNET_free (set);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  set->content = GNUNET_new (struct SetContent);
+  set->content->refcount = 1;
+  set->content->elements = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_YES);
+  set->cs = cs;
+  cs->set = set;
+  GNUNET_SERVICE_client_continue (cs->client);
+}
+
+
+/**
+ * Timeout happens iff:
+ *  - we suggested an operation to our listener,
+ *    but did not receive a response in time
+ *  - we got the channel from a peer but no #GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST
+ *
+ * @param cls channel context
+ */
+static void
+incoming_timeout_cb (void *cls)
+{
+  struct Operation *op = cls;
+
+  op->timeout_task = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Remote peer's incoming request timed out\n");
+  incoming_destroy (op);
+}
+
+
+/**
+ * Method called whenever another peer has added us to a channel the
+ * other peer initiated.  Only called (once) upon reception of data
+ * from a channel we listen on.
+ *
+ * The channel context represents the operation itself and gets added
+ * to a DLL, from where it gets looked up when our local listener
+ * client responds to a proposed/suggested operation or connects and
+ * associates with this operation.
+ *
+ * @param cls closure
+ * @param channel new handle to the channel
+ * @param source peer that started the channel
+ * @return initial channel context for the channel
+ *         returns NULL on error
+ */
+static void *
+channel_new_cb (void *cls,
+                struct GNUNET_CADET_Channel *channel,
+                const struct GNUNET_PeerIdentity *source)
+{
+  struct Listener *listener = cls;
+  struct Operation *op;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New incoming channel\n");
+  op = GNUNET_new (struct Operation);
+  op->listener = listener;
+  op->peer = *source;
+  op->channel = channel;
+  op->mq = GNUNET_CADET_get_mq (op->channel);
+  op->salt = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX);
+  op->timeout_task = GNUNET_SCHEDULER_add_delayed (INCOMING_CHANNEL_TIMEOUT,
+                                                   &incoming_timeout_cb,
+                                                   op);
+  GNUNET_CONTAINER_DLL_insert (listener->op_head, listener->op_tail, op);
+  return op;
+}
+
+
+/**
+ * Function called whenever a channel is destroyed.  Should clean up
+ * any associated state.  It must NOT call
+ * GNUNET_CADET_channel_destroy() on the channel.
+ *
+ * The peer_disconnect function is part of a a virtual table set initially either
+ * when a peer creates a new channel with us, or once we create
+ * a new channel ourselves (evaluate).
+ *
+ * Once we know the exact type of operation (union/intersection), the vt is
+ * replaced with an operation specific instance (_GSS_[op]_vt).
+ *
+ * @param channel_ctx place where local state associated
+ *                   with the channel is stored
+ * @param channel connection to the other end (henceforth invalid)
+ */
+static void
+channel_end_cb (void *channel_ctx, const struct GNUNET_CADET_Channel *channel)
+{
+  struct Operation *op = channel_ctx;
+
+  op->channel = NULL;
+  _GSS_operation_destroy2 (op);
+}
+
+
+/**
+ * This function probably should not exist
+ * and be replaced by inlining more specific
+ * logic in the various places where it is called.
+ */
+void
+_GSS_operation_destroy2 (struct Operation *op)
+{
+  struct GNUNET_CADET_Channel *channel;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "channel_end_cb called\n");
+  if (NULL != (channel = op->channel))
+  {
+    /* This will free op; called conditionally as this helper function
+       is also called from within the channel disconnect handler. */
+    op->channel = NULL;
+    GNUNET_CADET_channel_destroy (channel);
+  }
+  if (NULL != op->listener)
+  {
+    incoming_destroy (op);
+    return;
+  }
+  if (NULL != op->set)
+    op->set->vt->channel_death (op);
+  else
+    _GSS_operation_destroy (op, GNUNET_YES);
+  GNUNET_free (op);
+}
+
+
+/**
+ * Function called whenever an MQ-channel's transmission window size changes.
+ *
+ * The first callback in an outgoing channel will be with a non-zero value
+ * and will mean the channel is connected to the destination.
+ *
+ * For an incoming channel it will be called immediately after the
+ * #GNUNET_CADET_ConnectEventHandler, also with a non-zero value.
+ *
+ * @param cls Channel closure.
+ * @param channel Connection to the other end (henceforth invalid).
+ * @param window_size New window size. If the is more messages than buffer size
+ *                    this value will be negative..
+ */
+static void
+channel_window_cb (void *cls,
+                   const struct GNUNET_CADET_Channel *channel,
+                   int window_size)
+{
+  /* FIXME: not implemented, we could do flow control here... */
+}
+
+
+/**
+ * Called when a client wants to create a new listener.
+ *
+ * @param cls client that sent the message
+ * @param msg message sent by the client
+ */
+static void
+handle_client_listen (void *cls, const struct GNUNET_SET_ListenMessage *msg)
+{
+  struct ClientState *cs = cls;
+  struct GNUNET_MQ_MessageHandler cadet_handlers[] =
+  { GNUNET_MQ_hd_var_size (incoming_msg,
+                           GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST,
+                           struct OperationRequestMessage,
+                           NULL),
+    GNUNET_MQ_hd_var_size (union_p2p_ibf,
+                           GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF,
+                           struct IBFMessage,
+                           NULL),
+    GNUNET_MQ_hd_var_size (union_p2p_elements,
+                           GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS,
+                           struct GNUNET_SET_ElementMessage,
+                           NULL),
+    GNUNET_MQ_hd_var_size (union_p2p_offer,
+                           GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OFFER,
+                           struct GNUNET_MessageHeader,
+                           NULL),
+    GNUNET_MQ_hd_var_size (union_p2p_inquiry,
+                           GNUNET_MESSAGE_TYPE_SET_UNION_P2P_INQUIRY,
+                           struct InquiryMessage,
+                           NULL),
+    GNUNET_MQ_hd_var_size (union_p2p_demand,
+                           GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DEMAND,
+                           struct GNUNET_MessageHeader,
+                           NULL),
+    GNUNET_MQ_hd_fixed_size (union_p2p_done,
+                             GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (union_p2p_over,
+                             GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OVER,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (union_p2p_full_done,
+                             GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_DONE,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (union_p2p_request_full,
+                             GNUNET_MESSAGE_TYPE_SET_UNION_P2P_REQUEST_FULL,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_hd_var_size (union_p2p_strata_estimator,
+                           GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE,
+                           struct StrataEstimatorMessage,
+                           NULL),
+    GNUNET_MQ_hd_var_size (union_p2p_strata_estimator,
+                           GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC,
+                           struct StrataEstimatorMessage,
+                           NULL),
+    GNUNET_MQ_hd_var_size (union_p2p_full_element,
+                           GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_ELEMENT,
+                           struct GNUNET_SET_ElementMessage,
+                           NULL),
+    GNUNET_MQ_hd_fixed_size (intersection_p2p_element_info,
+                             GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO,
+                             struct IntersectionElementInfoMessage,
+                             NULL),
+    GNUNET_MQ_hd_var_size (intersection_p2p_bf,
+                           GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF,
+                           struct BFMessage,
+                           NULL),
+    GNUNET_MQ_hd_fixed_size (intersection_p2p_done,
+                             GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_DONE,
+                             struct IntersectionDoneMessage,
+                             NULL),
+    GNUNET_MQ_handler_end () };
+  struct Listener *listener;
+
+  if (NULL != cs->listener)
+  {
+    /* max. one active listener per client! */
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  listener = GNUNET_new (struct Listener);
+  listener->cs = cs;
+  cs->listener = listener;
+  listener->app_id = msg->app_id;
+  listener->operation = (enum GNUNET_SET_OperationType) ntohl (msg->operation);
+  GNUNET_CONTAINER_DLL_insert (listener_head, listener_tail, listener);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "New listener created (op %u, port %s)\n",
+              listener->operation,
+              GNUNET_h2s (&listener->app_id));
+  listener->open_port = GNUNET_CADET_open_port (cadet,
+                                                &msg->app_id,
+                                                &channel_new_cb,
+                                                listener,
+                                                &channel_window_cb,
+                                                &channel_end_cb,
+                                                cadet_handlers);
+  GNUNET_SERVICE_client_continue (cs->client);
+}
+
+
+/**
+ * Called when the listening client rejects an operation
+ * request by another peer.
+ *
+ * @param cls client that sent the message
+ * @param msg message sent by the client
+ */
+static void
+handle_client_reject (void *cls, const struct GNUNET_SET_RejectMessage *msg)
+{
+  struct ClientState *cs = cls;
+  struct Operation *op;
+
+  op = get_incoming (ntohl (msg->accept_reject_id));
+  if (NULL == op)
+  {
+    /* no matching incoming operation for this reject;
+       could be that the other peer already disconnected... */
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Client rejected unknown operation %u\n",
+                (unsigned int) ntohl (msg->accept_reject_id));
+    GNUNET_SERVICE_client_continue (cs->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Peer request (op %u, app %s) rejected by client\n",
+              op->listener->operation,
+              GNUNET_h2s (&cs->listener->app_id));
+  _GSS_operation_destroy2 (op);
+  GNUNET_SERVICE_client_continue (cs->client);
+}
+
+
+/**
+ * Called when a client wants to add or remove an element to a set it inhabits.
+ *
+ * @param cls client that sent the message
+ * @param msg message sent by the client
+ */
+static int
+check_client_mutation (void *cls, const struct GNUNET_SET_ElementMessage *msg)
+{
+  /* NOTE: Technically, we should probably check with the
+     block library whether the element we are given is well-formed */
+  return GNUNET_OK;
+}
+
+
+/**
+ * Called when a client wants to add or remove an element to a set it inhabits.
+ *
+ * @param cls client that sent the message
+ * @param msg message sent by the client
+ */
+static void
+handle_client_mutation (void *cls, const struct GNUNET_SET_ElementMessage *msg)
+{
+  struct ClientState *cs = cls;
+  struct Set *set;
+
+  if (NULL == (set = cs->set))
+  {
+    /* client without a set requested an operation */
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  GNUNET_SERVICE_client_continue (cs->client);
+
+  if (0 != set->content->iterator_count)
+  {
+    struct PendingMutation *pm;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Scheduling mutation on set\n");
+    pm = GNUNET_new (struct PendingMutation);
+    pm->msg =
+      (struct GNUNET_SET_ElementMessage *) GNUNET_copy_message (&msg->header);
+    pm->set = set;
+    GNUNET_CONTAINER_DLL_insert_tail (set->content->pending_mutations_head,
+                                      set->content->pending_mutations_tail,
+                                      pm);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing mutation on set\n");
+  execute_mutation (set, msg);
+}
+
+
+/**
+ * Advance the current generation of a set,
+ * adding exclusion ranges if necessary.
+ *
+ * @param set the set where we want to advance the generation
+ */
+static void
+advance_generation (struct Set *set)
+{
+  struct GenerationRange r;
+
+  if (set->current_generation == set->content->latest_generation)
+  {
+    set->content->latest_generation++;
+    set->current_generation++;
+    return;
+  }
+
+  GNUNET_assert (set->current_generation < set->content->latest_generation);
+
+  r.start = set->current_generation + 1;
+  r.end = set->content->latest_generation + 1;
+  set->content->latest_generation = r.end;
+  set->current_generation = r.end;
+  GNUNET_array_append (set->excluded_generations,
+                       set->excluded_generations_size,
+                       r);
+}
+
+
+/**
+ * Called when a client wants to initiate a set operation with another
+ * peer.  Initiates the CADET connection to the listener and sends the
+ * request.
+ *
+ * @param cls client that sent the message
+ * @param msg message sent by the client
+ * @return #GNUNET_OK if the message is well-formed
+ */
+static int
+check_client_evaluate (void *cls, const struct GNUNET_SET_EvaluateMessage *msg)
+{
+  /* FIXME: suboptimal, even if the context below could be NULL,
+     there are malformed messages this does not check for... */
+  return GNUNET_OK;
+}
+
+
+/**
+ * Called when a client wants to initiate a set operation with another
+ * peer.  Initiates the CADET connection to the listener and sends the
+ * request.
+ *
+ * @param cls client that sent the message
+ * @param msg message sent by the client
+ */
+static void
+handle_client_evaluate (void *cls, const struct GNUNET_SET_EvaluateMessage *msg)
+{
+  struct ClientState *cs = cls;
+  struct Operation *op = GNUNET_new (struct Operation);
+  const struct GNUNET_MQ_MessageHandler cadet_handlers[] =
+  { GNUNET_MQ_hd_var_size (incoming_msg,
+                           GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST,
+                           struct OperationRequestMessage,
+                           op),
+    GNUNET_MQ_hd_var_size (union_p2p_ibf,
+                           GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF,
+                           struct IBFMessage,
+                           op),
+    GNUNET_MQ_hd_var_size (union_p2p_elements,
+                           GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS,
+                           struct GNUNET_SET_ElementMessage,
+                           op),
+    GNUNET_MQ_hd_var_size (union_p2p_offer,
+                           GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OFFER,
+                           struct GNUNET_MessageHeader,
+                           op),
+    GNUNET_MQ_hd_var_size (union_p2p_inquiry,
+                           GNUNET_MESSAGE_TYPE_SET_UNION_P2P_INQUIRY,
+                           struct InquiryMessage,
+                           op),
+    GNUNET_MQ_hd_var_size (union_p2p_demand,
+                           GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DEMAND,
+                           struct GNUNET_MessageHeader,
+                           op),
+    GNUNET_MQ_hd_fixed_size (union_p2p_done,
+                             GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE,
+                             struct GNUNET_MessageHeader,
+                             op),
+    GNUNET_MQ_hd_fixed_size (union_p2p_over,
+                             GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OVER,
+                             struct GNUNET_MessageHeader,
+                             op),
+    GNUNET_MQ_hd_fixed_size (union_p2p_full_done,
+                             GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_DONE,
+                             struct GNUNET_MessageHeader,
+                             op),
+    GNUNET_MQ_hd_fixed_size (union_p2p_request_full,
+                             GNUNET_MESSAGE_TYPE_SET_UNION_P2P_REQUEST_FULL,
+                             struct GNUNET_MessageHeader,
+                             op),
+    GNUNET_MQ_hd_var_size (union_p2p_strata_estimator,
+                           GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE,
+                           struct StrataEstimatorMessage,
+                           op),
+    GNUNET_MQ_hd_var_size (union_p2p_strata_estimator,
+                           GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC,
+                           struct StrataEstimatorMessage,
+                           op),
+    GNUNET_MQ_hd_var_size (union_p2p_full_element,
+                           GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_ELEMENT,
+                           struct GNUNET_SET_ElementMessage,
+                           op),
+    GNUNET_MQ_hd_fixed_size (intersection_p2p_element_info,
+                             GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO,
+                             struct IntersectionElementInfoMessage,
+                             op),
+    GNUNET_MQ_hd_var_size (intersection_p2p_bf,
+                           GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF,
+                           struct BFMessage,
+                           op),
+    GNUNET_MQ_hd_fixed_size (intersection_p2p_done,
+                             GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_DONE,
+                             struct IntersectionDoneMessage,
+                             op),
+    GNUNET_MQ_handler_end () };
+  struct Set *set;
+  const struct GNUNET_MessageHeader *context;
+
+  if (NULL == (set = cs->set))
+  {
+    GNUNET_break (0);
+    GNUNET_free (op);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  op->salt = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, UINT32_MAX);
+  op->peer = msg->target_peer;
+  op->result_mode = ntohl (msg->result_mode);
+  op->client_request_id = ntohl (msg->request_id);
+  op->byzantine = msg->byzantine;
+  op->byzantine_lower_bound = msg->byzantine_lower_bound;
+  op->force_full = msg->force_full;
+  op->force_delta = msg->force_delta;
+  context = GNUNET_MQ_extract_nested_mh (msg);
+
+  /* Advance generation values, so that
+     mutations won't interfer with the running operation. */
+  op->set = set;
+  op->generation_created = set->current_generation;
+  advance_generation (set);
+  GNUNET_CONTAINER_DLL_insert (set->ops_head, set->ops_tail, op);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Creating new CADET channel to port %s for set operation type %u\n",
+              GNUNET_h2s (&msg->app_id),
+              set->operation);
+  op->channel = GNUNET_CADET_channel_create (cadet,
+                                             op,
+                                             &msg->target_peer,
+                                             &msg->app_id,
+                                             &channel_window_cb,
+                                             &channel_end_cb,
+                                             cadet_handlers);
+  op->mq = GNUNET_CADET_get_mq (op->channel);
+  op->state = set->vt->evaluate (op, context);
+  if (NULL == op->state)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  GNUNET_SERVICE_client_continue (cs->client);
+}
+
+
+/**
+ * Handle an ack from a client, and send the next element. Note
+ * that we only expect acks for set elements, not after the
+ * #GNUNET_MESSAGE_TYPE_SET_ITER_DONE message.
+ *
+ * @param cls client the client
+ * @param ack the message
+ */
+static void
+handle_client_iter_ack (void *cls, const struct GNUNET_SET_IterAckMessage *ack)
+{
+  struct ClientState *cs = cls;
+  struct Set *set;
+
+  if (NULL == (set = cs->set))
+  {
+    /* client without a set acknowledged receiving a value */
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  if (NULL == set->iter)
+  {
+    /* client sent an ack, but we were not expecting one (as
+       set iteration has finished) */
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  GNUNET_SERVICE_client_continue (cs->client);
+  if (ntohl (ack->send_more))
+  {
+    send_client_element (set);
+  }
+  else
+  {
+    GNUNET_CONTAINER_multihashmap_iterator_destroy (set->iter);
+    set->iter = NULL;
+    set->iteration_id++;
+  }
+}
+
+
+/**
+ * Handle a request from the client to copy a set.
+ *
+ * @param cls the client
+ * @param mh the message
+ */
+static void
+handle_client_copy_lazy_prepare (void *cls,
+                                 const struct GNUNET_MessageHeader *mh)
+{
+  struct ClientState *cs = cls;
+  struct Set *set;
+  struct LazyCopyRequest *cr;
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_SET_CopyLazyResponseMessage *resp_msg;
+
+  if (NULL == (set = cs->set))
+  {
+    /* client without a set requested an operation */
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Client requested creation of lazy copy\n");
+  cr = GNUNET_new (struct LazyCopyRequest);
+  cr->cookie = ++lazy_copy_cookie;
+  cr->source_set = set;
+  GNUNET_CONTAINER_DLL_insert (lazy_copy_head, lazy_copy_tail, cr);
+  ev = GNUNET_MQ_msg (resp_msg, GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_RESPONSE);
+  resp_msg->cookie = cr->cookie;
+  GNUNET_MQ_send (set->cs->mq, ev);
+  GNUNET_SERVICE_client_continue (cs->client);
+}
+
+
+/**
+ * Handle a request from the client to connect to a copy of a set.
+ *
+ * @param cls the client
+ * @param msg the message
+ */
+static void
+handle_client_copy_lazy_connect (
+  void *cls,
+  const struct GNUNET_SET_CopyLazyConnectMessage *msg)
+{
+  struct ClientState *cs = cls;
+  struct LazyCopyRequest *cr;
+  struct Set *set;
+  int found;
+
+  if (NULL != cs->set)
+  {
+    /* There can only be one set per client */
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  found = GNUNET_NO;
+  for (cr = lazy_copy_head; NULL != cr; cr = cr->next)
+  {
+    if (cr->cookie == msg->cookie)
+    {
+      found = GNUNET_YES;
+      break;
+    }
+  }
+  if (GNUNET_NO == found)
+  {
+    /* client asked for copy with cookie we don't know */
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  GNUNET_CONTAINER_DLL_remove (lazy_copy_head, lazy_copy_tail, cr);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Client %p requested use of lazy copy\n",
+              cs);
+  set = GNUNET_new (struct Set);
+  switch (cr->source_set->operation)
+  {
+  case GNUNET_SET_OPERATION_INTERSECTION:
+    set->vt = _GSS_intersection_vt ();
+    break;
+
+  case GNUNET_SET_OPERATION_UNION:
+    set->vt = _GSS_union_vt ();
+    break;
+
+  default:
+    GNUNET_assert (0);
+    return;
+  }
+
+  if (NULL == set->vt->copy_state)
+  {
+    /* Lazy copy not supported for this set operation */
+    GNUNET_break (0);
+    GNUNET_free (set);
+    GNUNET_free (cr);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+
+  set->operation = cr->source_set->operation;
+  set->state = set->vt->copy_state (cr->source_set->state);
+  set->content = cr->source_set->content;
+  set->content->refcount++;
+
+  set->current_generation = cr->source_set->current_generation;
+  set->excluded_generations_size = cr->source_set->excluded_generations_size;
+  set->excluded_generations =
+    GNUNET_memdup (cr->source_set->excluded_generations,
+                   set->excluded_generations_size
+                   * sizeof(struct GenerationRange));
+
+  /* Advance the generation of the new set, so that mutations to the
+     of the cloned set and the source set are independent. */
+  advance_generation (set);
+  set->cs = cs;
+  cs->set = set;
+  GNUNET_free (cr);
+  GNUNET_SERVICE_client_continue (cs->client);
+}
+
+
+/**
+ * Handle a request from the client to cancel a running set operation.
+ *
+ * @param cls the client
+ * @param msg the message
+ */
+static void
+handle_client_cancel (void *cls, const struct GNUNET_SET_CancelMessage *msg)
+{
+  struct ClientState *cs = cls;
+  struct Set *set;
+  struct Operation *op;
+  int found;
+
+  if (NULL == (set = cs->set))
+  {
+    /* client without a set requested an operation */
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  found = GNUNET_NO;
+  for (op = set->ops_head; NULL != op; op = op->next)
+  {
+    if (op->client_request_id == ntohl (msg->request_id))
+    {
+      found = GNUNET_YES;
+      break;
+    }
+  }
+  if (GNUNET_NO == found)
+  {
+    /* It may happen that the operation was already destroyed due to
+     * the other peer disconnecting.  The client may not know about this
+     * yet and try to cancel the (just barely non-existent) operation.
+     * So this is not a hard error.
+     */GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Client canceled non-existent op %u\n",
+                (uint32_t) ntohl (msg->request_id));
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Client requested cancel for op %u\n",
+                (uint32_t) ntohl (msg->request_id));
+    _GSS_operation_destroy (op, GNUNET_YES);
+  }
+  GNUNET_SERVICE_client_continue (cs->client);
+}
+
+
+/**
+ * Handle a request from the client to accept a set operation that
+ * came from a remote peer.  We forward the accept to the associated
+ * operation for handling
+ *
+ * @param cls the client
+ * @param msg the message
+ */
+static void
+handle_client_accept (void *cls, const struct GNUNET_SET_AcceptMessage *msg)
+{
+  struct ClientState *cs = cls;
+  struct Set *set;
+  struct Operation *op;
+  struct GNUNET_SET_ResultMessage *result_message;
+  struct GNUNET_MQ_Envelope *ev;
+  struct Listener *listener;
+
+  if (NULL == (set = cs->set))
+  {
+    /* client without a set requested to accept */
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  op = get_incoming (ntohl (msg->accept_reject_id));
+  if (NULL == op)
+  {
+    /* It is not an error if the set op does not exist -- it may
+    * have been destroyed when the partner peer disconnected. */
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_INFO,
+      "Client %p accepted request %u of listener %p that is no longer active\n",
+      cs,
+      ntohl (msg->accept_reject_id),
+      cs->listener);
+    ev = GNUNET_MQ_msg (result_message, GNUNET_MESSAGE_TYPE_SET_RESULT);
+    result_message->request_id = msg->request_id;
+    result_message->result_status = htons (GNUNET_SET_STATUS_FAILURE);
+    GNUNET_MQ_send (set->cs->mq, ev);
+    GNUNET_SERVICE_client_continue (cs->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Client accepting request %u\n",
+              (uint32_t) ntohl (msg->accept_reject_id));
+  listener = op->listener;
+  op->listener = NULL;
+  GNUNET_CONTAINER_DLL_remove (listener->op_head, listener->op_tail, op);
+  op->set = set;
+  GNUNET_CONTAINER_DLL_insert (set->ops_head, set->ops_tail, op);
+  op->client_request_id = ntohl (msg->request_id);
+  op->result_mode = ntohl (msg->result_mode);
+  op->byzantine = msg->byzantine;
+  op->byzantine_lower_bound = msg->byzantine_lower_bound;
+  op->force_full = msg->force_full;
+  op->force_delta = msg->force_delta;
+
+  /* Advance generation values, so that future mutations do not
+     interfer with the running operation. */
+  op->generation_created = set->current_generation;
+  advance_generation (set);
+  GNUNET_assert (NULL == op->state);
+  op->state = set->vt->accept (op);
+  if (NULL == op->state)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cs->client);
+    return;
+  }
+  /* Now allow CADET to continue, as we did not do this in
+   #handle_incoming_msg (as we wanted to first see if the
+     local client would accept the request). */
+  GNUNET_CADET_receive_done (op->channel);
+  GNUNET_SERVICE_client_continue (cs->client);
+}
+
+
+/**
+ * Called to clean up, after a shutdown has been requested.
+ *
+ * @param cls closure, NULL
+ */
+static void
+shutdown_task (void *cls)
+{
+  /* Delay actual shutdown to allow service to disconnect clients */
+  in_shutdown = GNUNET_YES;
+  if (0 == num_clients)
+  {
+    if (NULL != cadet)
+    {
+      GNUNET_CADET_disconnect (cadet);
+      cadet = NULL;
+    }
+  }
+  GNUNET_STATISTICS_destroy (_GSS_statistics, GNUNET_YES);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "handled shutdown request\n");
+}
+
+
+/**
+ * Function called by the service's run
+ * method to run service-specific setup code.
+ *
+ * @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: need to modify SERVICE (!) API to allow
+     us to run a shutdown task *after* clients were
+     forcefully disconnected! */
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
+  _GSS_statistics = GNUNET_STATISTICS_create ("set", cfg);
+  cadet = GNUNET_CADET_connect (cfg);
+  if (NULL == cadet)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Could not connect to CADET service\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+}
+
+
+/**
+ * Define "main" method using service macro.
+ */
+GNUNET_SERVICE_MAIN (
+  "set",
+  GNUNET_SERVICE_OPTION_NONE,
+  &run,
+  &client_connect_cb,
+  &client_disconnect_cb,
+  NULL,
+  GNUNET_MQ_hd_fixed_size (client_accept,
+                           GNUNET_MESSAGE_TYPE_SET_ACCEPT,
+                           struct GNUNET_SET_AcceptMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_iter_ack,
+                           GNUNET_MESSAGE_TYPE_SET_ITER_ACK,
+                           struct GNUNET_SET_IterAckMessage,
+                           NULL),
+  GNUNET_MQ_hd_var_size (client_mutation,
+                         GNUNET_MESSAGE_TYPE_SET_ADD,
+                         struct GNUNET_SET_ElementMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (client_create_set,
+                           GNUNET_MESSAGE_TYPE_SET_CREATE,
+                           struct GNUNET_SET_CreateMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_iterate,
+                           GNUNET_MESSAGE_TYPE_SET_ITER_REQUEST,
+                           struct GNUNET_MessageHeader,
+                           NULL),
+  GNUNET_MQ_hd_var_size (client_evaluate,
+                         GNUNET_MESSAGE_TYPE_SET_EVALUATE,
+                         struct GNUNET_SET_EvaluateMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (client_listen,
+                           GNUNET_MESSAGE_TYPE_SET_LISTEN,
+                           struct GNUNET_SET_ListenMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_reject,
+                           GNUNET_MESSAGE_TYPE_SET_REJECT,
+                           struct GNUNET_SET_RejectMessage,
+                           NULL),
+  GNUNET_MQ_hd_var_size (client_mutation,
+                         GNUNET_MESSAGE_TYPE_SET_REMOVE,
+                         struct GNUNET_SET_ElementMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (client_cancel,
+                           GNUNET_MESSAGE_TYPE_SET_CANCEL,
+                           struct GNUNET_SET_CancelMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_copy_lazy_prepare,
+                           GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_PREPARE,
+                           struct GNUNET_MessageHeader,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_copy_lazy_connect,
+                           GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_CONNECT,
+                           struct GNUNET_SET_CopyLazyConnectMessage,
+                           NULL),
+  GNUNET_MQ_handler_end ());
+
+
+/* end of gnunet-service-set.c */
diff --git a/src/contrib/service/set/gnunet-service-set.h b/src/contrib/service/set/gnunet-service-set.h
new file mode 100644
index 000000000..abdec7f08
--- /dev/null
+++ b/src/contrib/service/set/gnunet-service-set.h
@@ -0,0 +1,665 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2013-2017 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file set/gnunet-service-set.h
+ * @brief common components for the implementation the different set operations
+ * @author Florian Dold
+ * @author Christian Grothoff
+ */
+#ifndef GNUNET_SERVICE_SET_H_PRIVATE
+#define GNUNET_SERVICE_SET_H_PRIVATE
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_applications.h"
+#include "gnunet_core_service.h"
+#include "gnunet_cadet_service.h"
+#include "gnunet_set_service.h"
+#include "set.h"
+
+
+/**
+ * Implementation-specific set state.  Used as opaque pointer, and
+ * specified further in the respective implementation.
+ */
+struct SetState;
+
+/**
+ * Implementation-specific set operation.  Used as opaque pointer, and
+ * specified further in the respective implementation.
+ */
+struct OperationState;
+
+/**
+ * A set that supports a specific operation with other peers.
+ */
+struct Set;
+
+/**
+ * Information about an element element in the set.  All elements are
+ * stored in a hash-table from their hash-code to their 'struct
+ * Element', so that the remove and add operations are reasonably
+ * fast.
+ */
+struct ElementEntry;
+
+/**
+ * Operation context used to execute a set operation.
+ */
+struct Operation;
+
+
+/**
+ * Signature of functions that create the implementation-specific
+ * state for a set supporting a specific operation.
+ *
+ * @return a set state specific to the supported operation, NULL on error
+ */
+typedef struct SetState *
+(*SetCreateImpl) (void);
+
+
+/**
+ * Signature of functions that implement the add/remove functionality
+ * for a set supporting a specific operation.
+ *
+ * @param set implementation-specific set state
+ * @param ee element message from the client
+ */
+typedef void
+(*SetAddRemoveImpl) (struct SetState *state,
+                     struct ElementEntry *ee);
+
+
+/**
+ * Make a copy of a set's internal state.
+ *
+ * @param state set state to copy
+ * @return copy of the internal state
+ */
+typedef struct SetState *
+(*SetCopyStateImpl) (struct SetState *state);
+
+
+/**
+ * Signature of functions that implement the destruction of the
+ * implementation-specific set state.
+ *
+ * @param state the set state, contains implementation-specific data
+ */
+typedef void
+(*SetDestroyImpl) (struct SetState *state);
+
+
+/**
+ * Signature of functions that implement accepting a set operation.
+ *
+ * @param op operation that is created by accepting the operation,
+ *        should be initialized by the implementation
+ * @return operation-specific state to keep in @a op
+ */
+typedef struct OperationState *
+(*OpAcceptImpl) (struct Operation *op);
+
+
+/**
+ * Signature of functions that implement starting the evaluation of
+ * set operations.
+ *
+ * @param op operation that is created, should be initialized to
+ *        begin the evaluation
+ * @param opaque_context message to be transmitted to the listener
+ *        to convince it to accept, may be NULL
+ * @return operation-specific state to keep in @a op
+ */
+typedef struct OperationState *
+(*OpEvaluateImpl) (struct Operation *op,
+                   const struct GNUNET_MessageHeader *opaque_context);
+
+/**
+ * Signature of functions that implement operation cancellation.
+ * This includes notifying the client about the operation's final
+ * state.
+ *
+ * @param op operation state
+ */
+typedef void
+(*OpCancelImpl) (struct Operation *op);
+
+
+/**
+ * Signature of functions called when the CADET channel died.
+ *
+ * @param op operation state
+ */
+typedef void
+(*OpChannelDeathImpl) (struct Operation *op);
+
+
+/**
+ * Dispatch table for a specific set operation.  Every set operation
+ * has to implement the callback in this struct.
+ */
+struct SetVT
+{
+  /**
+   * Callback for the set creation.
+   */
+  SetCreateImpl create;
+
+  /**
+   * Callback for element insertion
+   */
+  SetAddRemoveImpl add;
+
+  /**
+   * Callback for element removal.
+   */
+  SetAddRemoveImpl remove;
+
+  /**
+   * Callback for making a copy of a set's internal state.
+   */
+  SetCopyStateImpl copy_state;
+
+  /**
+   * Callback for destruction of the set state.
+   */
+  SetDestroyImpl destroy_set;
+
+  /**
+   * Callback for accepting a set operation request
+   */
+  OpAcceptImpl accept;
+
+  /**
+   * Callback for starting evaluation with a remote peer.
+   */
+  OpEvaluateImpl evaluate;
+
+  /**
+   * Callback for canceling an operation.
+   */
+  OpCancelImpl cancel;
+
+  /**
+   * Callback called in case the CADET channel died.
+   */
+  OpChannelDeathImpl channel_death;
+};
+
+
+/**
+ * MutationEvent gives information about changes
+ * to an element (removal / addition) in a set content.
+ */
+struct MutationEvent
+{
+  /**
+   * First generation affected by this mutation event.
+   *
+   * If @a generation is 0, this mutation event is a list
+   * sentinel element.
+   */
+  unsigned int generation;
+
+  /**
+   * If @a added is #GNUNET_YES, then this is a
+   * `remove` event, otherwise it is an `add` event.
+   */
+  int added;
+};
+
+
+/**
+ * Information about an element element in the set.  All elements are
+ * stored in a hash-table from their hash-code to their `struct
+ * Element`, so that the remove and add operations are reasonably
+ * fast.
+ */
+struct ElementEntry
+{
+  /**
+   * The actual element. The data for the element
+   * should be allocated at the end of this struct.
+   */
+  struct GNUNET_SET_Element element;
+
+  /**
+   * Hash of the element.  For set union: Will be used to derive the
+   * different IBF keys for different salts.
+   */
+  struct GNUNET_HashCode element_hash;
+
+  /**
+   * If @a mutations is not NULL, it contains
+   * a list of mutations, ordered by increasing generation.
+   * The list is terminated by a sentinel event with `generation`
+   * set to 0.
+   *
+   * If @a mutations is NULL, then this element exists in all generations
+   * of the respective set content this element belongs to.
+   */
+  struct MutationEvent *mutations;
+
+  /**
+   * Number of elements in the array @a mutations.
+   */
+  unsigned int mutations_size;
+
+  /**
+   * #GNUNET_YES if the element is a remote element, and does not belong
+   * to the operation's set.
+   */
+  int remote;
+};
+
+
+/**
+ * A listener is inhabited by a client, and waits for evaluation
+ * requests from remote peers.
+ */
+struct Listener;
+
+
+/**
+ * State we keep per client.
+ */
+struct ClientState
+{
+  /**
+   * Set, if associated with the client, otherwise NULL.
+   */
+  struct Set *set;
+
+  /**
+   * Listener, if associated with the client, otherwise NULL.
+   */
+  struct Listener *listener;
+
+  /**
+   * Client handle.
+   */
+  struct GNUNET_SERVICE_Client *client;
+
+  /**
+   * Message queue.
+   */
+  struct GNUNET_MQ_Handle *mq;
+};
+
+
+/**
+ * Operation context used to execute a set operation.
+ */
+struct Operation
+{
+  /**
+   * Kept in a DLL of the listener, if @e listener is non-NULL.
+   */
+  struct Operation *next;
+
+  /**
+   * Kept in a DLL of the listener, if @e listener is non-NULL.
+   */
+  struct Operation *prev;
+
+  /**
+   * Channel to the peer.
+   */
+  struct GNUNET_CADET_Channel *channel;
+
+  /**
+   * Port this operation runs on.
+   */
+  struct Listener *listener;
+
+  /**
+   * Message queue for the channel.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Context message, may be NULL.
+   */
+  struct GNUNET_MessageHeader *context_msg;
+
+  /**
+   * Set associated with the operation, NULL until the spec has been
+   * associated with a set.
+   */
+  struct Set *set;
+
+  /**
+   * Operation-specific operation state.  Note that the exact
+   * type depends on this being a union or intersection operation
+   * (and thus on @e vt).
+   */
+  struct OperationState *state;
+
+  /**
+   * The identity of the requesting peer.  Needs to
+   * be stored here as the op spec might not have been created yet.
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /**
+   * Timeout task, if the incoming peer has not been accepted
+   * after the timeout, it will be disconnected.
+   */
+  struct GNUNET_SCHEDULER_Task *timeout_task;
+
+  /**
+   * Salt to use for the operation.
+   */
+  uint32_t salt;
+
+  /**
+   * Remote peers element count
+   */
+  uint32_t remote_element_count;
+
+  /**
+   * ID used to identify an operation between service and client
+   */
+  uint32_t client_request_id;
+
+  /**
+   * When are elements sent to the client, and which elements are sent?
+   */
+  enum GNUNET_SET_ResultMode result_mode;
+
+  /**
+   * Always use delta operation instead of sending full sets,
+   * even it it's less efficient.
+   */
+  int force_delta;
+
+  /**
+   * Always send full sets, even if delta operations would
+   * be more efficient.
+   */
+  int force_full;
+
+  /**
+   * #GNUNET_YES to fail operations where Byzantine faults
+   * are suspected
+   */
+  int byzantine;
+
+  /**
+   * Lower bound for the set size, used only when
+   * byzantine mode is enabled.
+   */
+  int byzantine_lower_bound;
+
+  /**
+   * Unique request id for the request from a remote peer, sent to the
+   * client, which will accept or reject the request.  Set to '0' iff
+   * the request has not been suggested yet.
+   */
+  uint32_t suggest_id;
+
+  /**
+   * Generation in which the operation handle
+   * was created.
+   */
+  unsigned int generation_created;
+};
+
+
+/**
+ * SetContent stores the actual set elements, which may be shared by
+ * multiple generations derived from one set.
+ */
+struct SetContent
+{
+  /**
+   * Maps `struct GNUNET_HashCode *` to `struct ElementEntry *`.
+   */
+  struct GNUNET_CONTAINER_MultiHashMap *elements;
+
+  /**
+   * Mutations requested by the client that we're
+   * unable to execute right now because we're iterating
+   * over the underlying hash map of elements.
+   */
+  struct PendingMutation *pending_mutations_head;
+
+  /**
+   * Mutations requested by the client that we're
+   * unable to execute right now because we're iterating
+   * over the underlying hash map of elements.
+   */
+  struct PendingMutation *pending_mutations_tail;
+
+  /**
+   * Number of references to the content.
+   */
+  unsigned int refcount;
+
+  /**
+   * FIXME: document!
+   */
+  unsigned int latest_generation;
+
+  /**
+   * Number of concurrently active iterators.
+   */
+  int iterator_count;
+};
+
+
+struct GenerationRange
+{
+  /**
+   * First generation that is excluded.
+   */
+  unsigned int start;
+
+  /**
+   * Generation after the last excluded generation.
+   */
+  unsigned int end;
+};
+
+
+/**
+ * Information about a mutation to apply to a set.
+ */
+struct PendingMutation
+{
+  /**
+   * Mutations are kept in a DLL.
+   */
+  struct PendingMutation *prev;
+
+  /**
+   * Mutations are kept in a DLL.
+   */
+  struct PendingMutation *next;
+
+  /**
+   * Set this mutation is about.
+   */
+  struct Set *set;
+
+  /**
+   * Message that describes the desired mutation.
+   * May only be a #GNUNET_MESSAGE_TYPE_SET_ADD or
+   * #GNUNET_MESSAGE_TYPE_SET_REMOVE.
+   */
+  struct GNUNET_SET_ElementMessage *msg;
+};
+
+
+/**
+ * A set that supports a specific operation with other peers.
+ */
+struct Set
+{
+  /**
+   * Sets are held in a doubly linked list (in `sets_head` and `sets_tail`).
+   */
+  struct Set *next;
+
+  /**
+   * Sets are held in a doubly linked list.
+   */
+  struct Set *prev;
+
+  /**
+   * Client that owns the set.  Only one client may own a set,
+   * and there can only be one set per client.
+   */
+  struct ClientState *cs;
+
+  /**
+   * Content, possibly shared by multiple sets,
+   * and thus reference counted.
+   */
+  struct SetContent *content;
+
+  /**
+   * Virtual table for this set.  Determined by the operation type of
+   * this set.
+   *
+   * Used only for Add/remove of elements and when receiving an incoming
+   * operation from a remote peer.
+   */
+  const struct SetVT *vt;
+
+  /**
+   * Implementation-specific state.
+   */
+  struct SetState *state;
+
+  /**
+   * Current state of iterating elements for the client.
+   * NULL if we are not currently iterating.
+   */
+  struct GNUNET_CONTAINER_MultiHashMapIterator *iter;
+
+  /**
+   * Evaluate operations are held in a linked list.
+   */
+  struct Operation *ops_head;
+
+  /**
+   * Evaluate operations are held in a linked list.
+   */
+  struct Operation *ops_tail;
+
+  /**
+   * List of generations we have to exclude, due to lazy copies.
+   */
+  struct GenerationRange *excluded_generations;
+
+  /**
+   * Current generation, that is, number of previously executed
+   * operations and lazy copies on the underlying set content.
+   */
+  unsigned int current_generation;
+
+  /**
+   * Number of elements in array @a excluded_generations.
+   */
+  unsigned int excluded_generations_size;
+
+  /**
+   * Type of operation supported for this set
+   */
+  enum GNUNET_SET_OperationType operation;
+
+  /**
+   * Generation we're currently iteration over.
+   */
+  unsigned int iter_generation;
+
+  /**
+   * Each @e iter is assigned a unique number, so that the client
+   * can distinguish iterations.
+   */
+  uint16_t iteration_id;
+};
+
+
+extern struct GNUNET_STATISTICS_Handle *_GSS_statistics;
+
+
+/**
+ * Destroy the given operation.   Used for any operation where both
+ * peers were known and that thus actually had a vt and channel.  Must
+ * not be used for operations where 'listener' is still set and we do
+ * not know the other peer.
+ *
+ * Call the implementation-specific cancel function of the operation.
+ * Disconnects from the remote peer.  Does not disconnect the client,
+ * as there may be multiple operations per set.
+ *
+ * @param op operation to destroy
+ * @param gc #GNUNET_YES to perform garbage collection on the set
+ */
+void
+_GSS_operation_destroy (struct Operation *op,
+                        int gc);
+
+
+/**
+ * This function probably should not exist
+ * and be replaced by inlining more specific
+ * logic in the various places where it is called.
+ */
+void
+_GSS_operation_destroy2 (struct Operation *op);
+
+
+/**
+ * Get the table with implementing functions for set union.
+ *
+ * @return the operation specific VTable
+ */
+const struct SetVT *
+_GSS_union_vt (void);
+
+
+/**
+ * Get the table with implementing functions for set intersection.
+ *
+ * @return the operation specific VTable
+ */
+const struct SetVT *
+_GSS_intersection_vt (void);
+
+
+/**
+ * Is element @a ee part of the set used by @a op?
+ *
+ * @param ee element to test
+ * @param op operation the defines the set and its generation
+ * @return #GNUNET_YES if the element is in the set, #GNUNET_NO if not
+ */
+int
+_GSS_is_element_of_operation (struct ElementEntry *ee,
+                              struct Operation *op);
+
+
+#endif
diff --git a/src/contrib/service/set/gnunet-service-set_intersection.c b/src/contrib/service/set/gnunet-service-set_intersection.c
new file mode 100644
index 000000000..51a8d0dbc
--- /dev/null
+++ b/src/contrib/service/set/gnunet-service-set_intersection.c
@@ -0,0 +1,1324 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2013-2017 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file set/gnunet-service-set_intersection.c
+ * @brief two-peer set intersection
+ * @author Christian Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_statistics_service.h"
+#include "gnunet-service-set.h"
+#include "gnunet_block_lib.h"
+#include "gnunet-service-set_protocol.h"
+#include "gnunet-service-set_intersection.h"
+#include <gcrypt.h>
+
+
+/**
+ * Current phase we are in for a intersection operation.
+ */
+enum IntersectionOperationPhase
+{
+  /**
+   * We are just starting.
+   */
+  PHASE_INITIAL,
+
+  /**
+   * We have send the number of our elements to the other
+   * peer, but did not setup our element set yet.
+   */
+  PHASE_COUNT_SENT,
+
+  /**
+   * We have initialized our set and are now reducing it by exchanging
+   * Bloom filters until one party notices the their element hashes
+   * are equal.
+   */
+  PHASE_BF_EXCHANGE,
+
+  /**
+   * We must next send the P2P DONE message (after finishing mostly
+   * with the local client).  Then we will wait for the channel to close.
+   */
+  PHASE_MUST_SEND_DONE,
+
+  /**
+   * We have received the P2P DONE message, and must finish with the
+   * local client before terminating the channel.
+   */
+  PHASE_DONE_RECEIVED,
+
+  /**
+   * The protocol is over.  Results may still have to be sent to the
+   * client.
+   */
+  PHASE_FINISHED
+};
+
+
+/**
+ * State of an evaluate operation with another peer.
+ */
+struct OperationState
+{
+  /**
+   * The bf we currently receive
+   */
+  struct GNUNET_CONTAINER_BloomFilter *remote_bf;
+
+  /**
+   * BF of the set's element.
+   */
+  struct GNUNET_CONTAINER_BloomFilter *local_bf;
+
+  /**
+   * Remaining elements in the intersection operation.
+   * Maps element-id-hashes to 'elements in our set'.
+   */
+  struct GNUNET_CONTAINER_MultiHashMap *my_elements;
+
+  /**
+   * Iterator for sending the final set of @e my_elements to the client.
+   */
+  struct GNUNET_CONTAINER_MultiHashMapIterator *full_result_iter;
+
+  /**
+   * Evaluate operations are held in a linked list.
+   */
+  struct OperationState *next;
+
+  /**
+   * Evaluate operations are held in a linked list.
+   */
+  struct OperationState *prev;
+
+  /**
+   * For multipart BF transmissions, we have to store the
+   * bloomfilter-data until we fully received it.
+   */
+  char *bf_data;
+
+  /**
+   * XOR of the keys of all of the elements (remaining) in my set.
+   * Always updated when elements are added or removed to
+   * @e my_elements.
+   */
+  struct GNUNET_HashCode my_xor;
+
+  /**
+   * XOR of the keys of all of the elements (remaining) in
+   * the other peer's set.  Updated when we receive the
+   * other peer's Bloom filter.
+   */
+  struct GNUNET_HashCode other_xor;
+
+  /**
+   * How many bytes of @e bf_data are valid?
+   */
+  uint32_t bf_data_offset;
+
+  /**
+   * Current element count contained within @e my_elements.
+   * (May differ briefly during initialization.)
+   */
+  uint32_t my_element_count;
+
+  /**
+   * size of the bloomfilter in @e bf_data.
+   */
+  uint32_t bf_data_size;
+
+  /**
+   * size of the bloomfilter
+   */
+  uint32_t bf_bits_per_element;
+
+  /**
+   * Salt currently used for BF construction (by us or the other peer,
+   * depending on where we are in the code).
+   */
+  uint32_t salt;
+
+  /**
+   * Current state of the operation.
+   */
+  enum IntersectionOperationPhase phase;
+
+  /**
+   * Generation in which the operation handle
+   * was created.
+   */
+  unsigned int generation_created;
+
+  /**
+   * Did we send the client that we are done?
+   */
+  int client_done_sent;
+
+  /**
+   * Set whenever we reach the state where the death of the
+   * channel is perfectly find and should NOT result in the
+   * operation being cancelled.
+   */
+  int channel_death_expected;
+};
+
+
+/**
+ * Extra state required for efficient set intersection.
+ * Merely tracks the total number of elements.
+ */
+struct SetState
+{
+  /**
+   * Number of currently valid elements in the set which have not been
+   * removed.
+   */
+  uint32_t current_set_element_count;
+};
+
+
+/**
+ * If applicable in the current operation mode, send a result message
+ * to the client indicating we removed an element.
+ *
+ * @param op intersection operation
+ * @param element element to send
+ */
+static void
+send_client_removed_element (struct Operation *op,
+                             struct GNUNET_SET_Element *element)
+{
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_SET_ResultMessage *rm;
+
+  if (GNUNET_SET_RESULT_REMOVED != op->result_mode)
+    return; /* Wrong mode for transmitting removed elements */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending removed element (size %u) to client\n",
+              element->size);
+  GNUNET_STATISTICS_update (_GSS_statistics,
+                            "# Element removed messages sent",
+                            1,
+                            GNUNET_NO);
+  GNUNET_assert (0 != op->client_request_id);
+  ev = GNUNET_MQ_msg_extra (rm,
+                            element->size,
+                            GNUNET_MESSAGE_TYPE_SET_RESULT);
+  if (NULL == ev)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  rm->result_status = htons (GNUNET_SET_STATUS_OK);
+  rm->request_id = htonl (op->client_request_id);
+  rm->element_type = element->element_type;
+  GNUNET_memcpy (&rm[1],
+                 element->data,
+                 element->size);
+  GNUNET_MQ_send (op->set->cs->mq,
+                  ev);
+}
+
+
+/**
+ * Fills the "my_elements" hashmap with all relevant elements.
+ *
+ * @param cls the `struct Operation *` we are performing
+ * @param key current key code
+ * @param value the `struct ElementEntry *` from the hash map
+ * @return #GNUNET_YES (we should continue to iterate)
+ */
+static int
+filtered_map_initialization (void *cls,
+                             const struct GNUNET_HashCode *key,
+                             void *value)
+{
+  struct Operation *op = cls;
+  struct ElementEntry *ee = value;
+  struct GNUNET_HashCode mutated_hash;
+
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "FIMA called for %s:%u\n",
+              GNUNET_h2s (&ee->element_hash),
+              ee->element.size);
+
+  if (GNUNET_NO == _GSS_is_element_of_operation (ee, op))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Reduced initialization, not starting with %s:%u (wrong generation)\n",
+                GNUNET_h2s (&ee->element_hash),
+                ee->element.size);
+    return GNUNET_YES;   /* element not valid in our operation's generation */
+  }
+
+  /* Test if element is in other peer's bloomfilter */
+  GNUNET_BLOCK_mingle_hash (&ee->element_hash,
+                            op->state->salt,
+                            &mutated_hash);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Testing mingled hash %s with salt %u\n",
+              GNUNET_h2s (&mutated_hash),
+              op->state->salt);
+  if (GNUNET_NO ==
+      GNUNET_CONTAINER_bloomfilter_test (op->state->remote_bf,
+                                         &mutated_hash))
+  {
+    /* remove this element */
+    send_client_removed_element (op,
+                                 &ee->element);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Reduced initialization, not starting with %s:%u\n",
+                GNUNET_h2s (&ee->element_hash),
+                ee->element.size);
+    return GNUNET_YES;
+  }
+  op->state->my_element_count++;
+  GNUNET_CRYPTO_hash_xor (&op->state->my_xor,
+                          &ee->element_hash,
+                          &op->state->my_xor);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Filtered initialization of my_elements, adding %s:%u\n",
+              GNUNET_h2s (&ee->element_hash),
+              ee->element.size);
+  GNUNET_break (GNUNET_YES ==
+                GNUNET_CONTAINER_multihashmap_put (op->state->my_elements,
+                                                   &ee->element_hash,
+                                                   ee,
+                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+
+  return GNUNET_YES;
+}
+
+
+/**
+ * Removes elements from our hashmap if they are not contained within the
+ * provided remote bloomfilter.
+ *
+ * @param cls closure with the `struct Operation *`
+ * @param key current key code
+ * @param value value in the hash map
+ * @return #GNUNET_YES (we should continue to iterate)
+ */
+static int
+iterator_bf_reduce (void *cls,
+                    const struct GNUNET_HashCode *key,
+                    void *value)
+{
+  struct Operation *op = cls;
+  struct ElementEntry *ee = value;
+  struct GNUNET_HashCode mutated_hash;
+
+  GNUNET_BLOCK_mingle_hash (&ee->element_hash,
+                            op->state->salt,
+                            &mutated_hash);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Testing mingled hash %s with salt %u\n",
+              GNUNET_h2s (&mutated_hash),
+              op->state->salt);
+  if (GNUNET_NO ==
+      GNUNET_CONTAINER_bloomfilter_test (op->state->remote_bf,
+                                         &mutated_hash))
+  {
+    GNUNET_break (0 < op->state->my_element_count);
+    op->state->my_element_count--;
+    GNUNET_CRYPTO_hash_xor (&op->state->my_xor,
+                            &ee->element_hash,
+                            &op->state->my_xor);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Bloom filter reduction of my_elements, removing %s:%u\n",
+                GNUNET_h2s (&ee->element_hash),
+                ee->element.size);
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multihashmap_remove (op->state->my_elements,
+                                                         &ee->element_hash,
+                                                         ee));
+    send_client_removed_element (op,
+                                 &ee->element);
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Bloom filter reduction of my_elements, keeping %s:%u\n",
+                GNUNET_h2s (&ee->element_hash),
+                ee->element.size);
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * Create initial bloomfilter based on all the elements given.
+ *
+ * @param cls the `struct Operation *`
+ * @param key current key code
+ * @param value the `struct ElementEntry` to process
+ * @return #GNUNET_YES (we should continue to iterate)
+ */
+static int
+iterator_bf_create (void *cls,
+                    const struct GNUNET_HashCode *key,
+                    void *value)
+{
+  struct Operation *op = cls;
+  struct ElementEntry *ee = value;
+  struct GNUNET_HashCode mutated_hash;
+
+  GNUNET_BLOCK_mingle_hash (&ee->element_hash,
+                            op->state->salt,
+                            &mutated_hash);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Initializing BF with hash %s with salt %u\n",
+              GNUNET_h2s (&mutated_hash),
+              op->state->salt);
+  GNUNET_CONTAINER_bloomfilter_add (op->state->local_bf,
+                                    &mutated_hash);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Inform the client that the intersection operation has failed,
+ * and proceed to destroy the evaluate operation.
+ *
+ * @param op the intersection operation to fail
+ */
+static void
+fail_intersection_operation (struct Operation *op)
+{
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_SET_ResultMessage *msg;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Intersection operation failed\n");
+  GNUNET_STATISTICS_update (_GSS_statistics,
+                            "# Intersection operations failed",
+                            1,
+                            GNUNET_NO);
+  if (NULL != op->state->my_elements)
+  {
+    GNUNET_CONTAINER_multihashmap_destroy (op->state->my_elements);
+    op->state->my_elements = NULL;
+  }
+  ev = GNUNET_MQ_msg (msg,
+                      GNUNET_MESSAGE_TYPE_SET_RESULT);
+  msg->result_status = htons (GNUNET_SET_STATUS_FAILURE);
+  msg->request_id = htonl (op->client_request_id);
+  msg->element_type = htons (0);
+  GNUNET_MQ_send (op->set->cs->mq,
+                  ev);
+  _GSS_operation_destroy (op,
+                          GNUNET_YES);
+}
+
+
+/**
+ * Send a bloomfilter to our peer.  After the result done message has
+ * been sent to the client, destroy the evaluate operation.
+ *
+ * @param op intersection operation
+ */
+static void
+send_bloomfilter (struct Operation *op)
+{
+  struct GNUNET_MQ_Envelope *ev;
+  struct BFMessage *msg;
+  uint32_t bf_size;
+  uint32_t bf_elementbits;
+  uint32_t chunk_size;
+  char *bf_data;
+  uint32_t offset;
+
+  /* We consider the ratio of the set sizes to determine
+     the number of bits per element, as the smaller set
+     should use more bits to maximize its set reduction
+     potential and minimize overall bandwidth consumption. */
+  bf_elementbits = 2 + ceil (log2 ((double)
+                                   (op->remote_element_count
+                                    / (double) op->state->my_element_count)));
+  if (bf_elementbits < 1)
+    bf_elementbits = 1; /* make sure k is not 0 */
+  /* optimize BF-size to ~50% of bits set */
+  bf_size = ceil ((double) (op->state->my_element_count
+                            * bf_elementbits / log (2)));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending Bloom filter (%u) of size %u bytes\n",
+              (unsigned int) bf_elementbits,
+              (unsigned int) bf_size);
+  op->state->local_bf = GNUNET_CONTAINER_bloomfilter_init (NULL,
+                                                           bf_size,
+                                                           bf_elementbits);
+  op->state->salt = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
+                                              UINT32_MAX);
+  GNUNET_CONTAINER_multihashmap_iterate (op->state->my_elements,
+                                         &iterator_bf_create,
+                                         op);
+
+  /* send our Bloom filter */
+  GNUNET_STATISTICS_update (_GSS_statistics,
+                            "# Intersection Bloom filters sent",
+                            1,
+                            GNUNET_NO);
+  chunk_size = 60 * 1024 - sizeof(struct BFMessage);
+  if (bf_size <= chunk_size)
+  {
+    /* singlepart */
+    chunk_size = bf_size;
+    ev = GNUNET_MQ_msg_extra (msg,
+                              chunk_size,
+                              GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF);
+    GNUNET_assert (GNUNET_SYSERR !=
+                   GNUNET_CONTAINER_bloomfilter_get_raw_data (
+                     op->state->local_bf,
+                     (char *) &msg[1],
+                     bf_size));
+    msg->sender_element_count = htonl (op->state->my_element_count);
+    msg->bloomfilter_total_length = htonl (bf_size);
+    msg->bits_per_element = htonl (bf_elementbits);
+    msg->sender_mutator = htonl (op->state->salt);
+    msg->element_xor_hash = op->state->my_xor;
+    GNUNET_MQ_send (op->mq, ev);
+  }
+  else
+  {
+    /* multipart */
+    bf_data = GNUNET_malloc (bf_size);
+    GNUNET_assert (GNUNET_SYSERR !=
+                   GNUNET_CONTAINER_bloomfilter_get_raw_data (
+                     op->state->local_bf,
+                     bf_data,
+                     bf_size));
+    offset = 0;
+    while (offset < bf_size)
+    {
+      if (bf_size - chunk_size < offset)
+        chunk_size = bf_size - offset;
+      ev = GNUNET_MQ_msg_extra (msg,
+                                chunk_size,
+                                GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF);
+      GNUNET_memcpy (&msg[1],
+                     &bf_data[offset],
+                     chunk_size);
+      offset += chunk_size;
+      msg->sender_element_count = htonl (op->state->my_element_count);
+      msg->bloomfilter_total_length = htonl (bf_size);
+      msg->bits_per_element = htonl (bf_elementbits);
+      msg->sender_mutator = htonl (op->state->salt);
+      msg->element_xor_hash = op->state->my_xor;
+      GNUNET_MQ_send (op->mq, ev);
+    }
+    GNUNET_free (bf_data);
+  }
+  GNUNET_CONTAINER_bloomfilter_free (op->state->local_bf);
+  op->state->local_bf = NULL;
+}
+
+
+/**
+ * Signal to the client that the operation has finished and
+ * destroy the operation.
+ *
+ * @param cls operation to destroy
+ */
+static void
+send_client_done_and_destroy (void *cls)
+{
+  struct Operation *op = cls;
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_SET_ResultMessage *rm;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Intersection succeeded, sending DONE to local client\n");
+  GNUNET_STATISTICS_update (_GSS_statistics,
+                            "# Intersection operations succeeded",
+                            1,
+                            GNUNET_NO);
+  ev = GNUNET_MQ_msg (rm,
+                      GNUNET_MESSAGE_TYPE_SET_RESULT);
+  rm->request_id = htonl (op->client_request_id);
+  rm->result_status = htons (GNUNET_SET_STATUS_DONE);
+  rm->element_type = htons (0);
+  GNUNET_MQ_send (op->set->cs->mq,
+                  ev);
+  _GSS_operation_destroy (op,
+                          GNUNET_YES);
+}
+
+
+/**
+ * Remember that we are done dealing with the local client
+ * AND have sent the other peer our message that we are done,
+ * so we are not just waiting for the channel to die before
+ * telling the local client that we are done as our last act.
+ *
+ * @param cls the `struct Operation`.
+ */
+static void
+finished_local_operations (void *cls)
+{
+  struct Operation *op = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "DONE sent to other peer, now waiting for other end to close the channel\n");
+  op->state->phase = PHASE_FINISHED;
+  op->state->channel_death_expected = GNUNET_YES;
+}
+
+
+/**
+ * Notify the other peer that we are done.  Once this message
+ * is out, we still need to notify the local client that we
+ * are done.
+ *
+ * @param op operation to notify for.
+ */
+static void
+send_p2p_done (struct Operation *op)
+{
+  struct GNUNET_MQ_Envelope *ev;
+  struct IntersectionDoneMessage *idm;
+
+  GNUNET_assert (PHASE_MUST_SEND_DONE == op->state->phase);
+  GNUNET_assert (GNUNET_NO == op->state->channel_death_expected);
+  ev = GNUNET_MQ_msg (idm,
+                      GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_DONE);
+  idm->final_element_count = htonl (op->state->my_element_count);
+  idm->element_xor_hash = op->state->my_xor;
+  GNUNET_MQ_notify_sent (ev,
+                         &finished_local_operations,
+                         op);
+  GNUNET_MQ_send (op->mq,
+                  ev);
+}
+
+
+/**
+ * Send all elements in the full result iterator.
+ *
+ * @param cls the `struct Operation *`
+ */
+static void
+send_remaining_elements (void *cls)
+{
+  struct Operation *op = cls;
+  const void *nxt;
+  const struct ElementEntry *ee;
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_SET_ResultMessage *rm;
+  const struct GNUNET_SET_Element *element;
+  int res;
+
+  res = GNUNET_CONTAINER_multihashmap_iterator_next (
+    op->state->full_result_iter,
+    NULL,
+    &nxt);
+  if (GNUNET_NO == res)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending done and destroy because iterator ran out\n");
+    GNUNET_CONTAINER_multihashmap_iterator_destroy (
+      op->state->full_result_iter);
+    op->state->full_result_iter = NULL;
+    if (PHASE_DONE_RECEIVED == op->state->phase)
+    {
+      op->state->phase = PHASE_FINISHED;
+      send_client_done_and_destroy (op);
+    }
+    else if (PHASE_MUST_SEND_DONE == op->state->phase)
+    {
+      send_p2p_done (op);
+    }
+    else
+    {
+      GNUNET_assert (0);
+    }
+    return;
+  }
+  ee = nxt;
+  element = &ee->element;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending element %s:%u to client (full set)\n",
+              GNUNET_h2s (&ee->element_hash),
+              element->size);
+  GNUNET_assert (0 != op->client_request_id);
+  ev = GNUNET_MQ_msg_extra (rm,
+                            element->size,
+                            GNUNET_MESSAGE_TYPE_SET_RESULT);
+  GNUNET_assert (NULL != ev);
+  rm->result_status = htons (GNUNET_SET_STATUS_OK);
+  rm->request_id = htonl (op->client_request_id);
+  rm->element_type = element->element_type;
+  GNUNET_memcpy (&rm[1],
+                 element->data,
+                 element->size);
+  GNUNET_MQ_notify_sent (ev,
+                         &send_remaining_elements,
+                         op);
+  GNUNET_MQ_send (op->set->cs->mq,
+                  ev);
+}
+
+
+/**
+ * Fills the "my_elements" hashmap with the initial set of
+ * (non-deleted) elements from the set of the specification.
+ *
+ * @param cls closure with the `struct Operation *`
+ * @param key current key code for the element
+ * @param value value in the hash map with the `struct ElementEntry *`
+ * @return #GNUNET_YES (we should continue to iterate)
+ */
+static int
+initialize_map_unfiltered (void *cls,
+                           const struct GNUNET_HashCode *key,
+                           void *value)
+{
+  struct ElementEntry *ee = value;
+  struct Operation *op = cls;
+
+  if (GNUNET_NO == _GSS_is_element_of_operation (ee, op))
+    return GNUNET_YES; /* element not live in operation's generation */
+  GNUNET_CRYPTO_hash_xor (&op->state->my_xor,
+                          &ee->element_hash,
+                          &op->state->my_xor);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Initial full initialization of my_elements, adding %s:%u\n",
+              GNUNET_h2s (&ee->element_hash),
+              ee->element.size);
+  GNUNET_break (GNUNET_YES ==
+                GNUNET_CONTAINER_multihashmap_put (op->state->my_elements,
+                                                   &ee->element_hash,
+                                                   ee,
+                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  return GNUNET_YES;
+}
+
+
+/**
+ * Send our element count to the peer, in case our element count is
+ * lower than theirs.
+ *
+ * @param op intersection operation
+ */
+static void
+send_element_count (struct Operation *op)
+{
+  struct GNUNET_MQ_Envelope *ev;
+  struct IntersectionElementInfoMessage *msg;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending our element count (%u)\n",
+              op->state->my_element_count);
+  ev = GNUNET_MQ_msg (msg,
+                      GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO);
+  msg->sender_element_count = htonl (op->state->my_element_count);
+  GNUNET_MQ_send (op->mq, ev);
+}
+
+
+/**
+ * We go first, initialize our map with all elements and
+ * send the first Bloom filter.
+ *
+ * @param op operation to start exchange for
+ */
+static void
+begin_bf_exchange (struct Operation *op)
+{
+  op->state->phase = PHASE_BF_EXCHANGE;
+  GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements,
+                                         &initialize_map_unfiltered,
+                                         op);
+  send_bloomfilter (op);
+}
+
+
+void
+handle_intersection_p2p_element_info (void *cls,
+                                      const struct
+                                      IntersectionElementInfoMessage *msg)
+{
+  struct Operation *op = cls;
+
+  if (GNUNET_SET_OPERATION_INTERSECTION != op->set->operation)
+  {
+    GNUNET_break_op (0);
+    fail_intersection_operation (op);
+    return;
+  }
+  op->remote_element_count = ntohl (msg->sender_element_count);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received remote element count (%u), I have %u\n",
+              op->remote_element_count,
+              op->state->my_element_count);
+  if (((PHASE_INITIAL != op->state->phase) &&
+       (PHASE_COUNT_SENT != op->state->phase)) ||
+      (op->state->my_element_count > op->remote_element_count) ||
+      (0 == op->state->my_element_count) ||
+      (0 == op->remote_element_count))
+  {
+    GNUNET_break_op (0);
+    fail_intersection_operation (op);
+    return;
+  }
+  GNUNET_break (NULL == op->state->remote_bf);
+  begin_bf_exchange (op);
+  GNUNET_CADET_receive_done (op->channel);
+}
+
+
+/**
+ * Process a Bloomfilter once we got all the chunks.
+ *
+ * @param op the intersection operation
+ */
+static void
+process_bf (struct Operation *op)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received BF in phase %u, foreign count is %u, my element count is %u/%u\n",
+              op->state->phase,
+              op->remote_element_count,
+              op->state->my_element_count,
+              GNUNET_CONTAINER_multihashmap_size (op->set->content->elements));
+  switch (op->state->phase)
+  {
+  case PHASE_INITIAL:
+    GNUNET_break_op (0);
+    fail_intersection_operation (op);
+    return;
+
+  case PHASE_COUNT_SENT:
+    /* This is the first BF being sent, build our initial map with
+       filtering in place */
+    op->state->my_element_count = 0;
+    GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements,
+                                           &filtered_map_initialization,
+                                           op);
+    break;
+
+  case PHASE_BF_EXCHANGE:
+    /* Update our set by reduction */
+    GNUNET_CONTAINER_multihashmap_iterate (op->state->my_elements,
+                                           &iterator_bf_reduce,
+                                           op);
+    break;
+
+  case PHASE_MUST_SEND_DONE:
+    GNUNET_break_op (0);
+    fail_intersection_operation (op);
+    return;
+
+  case PHASE_DONE_RECEIVED:
+    GNUNET_break_op (0);
+    fail_intersection_operation (op);
+    return;
+
+  case PHASE_FINISHED:
+    GNUNET_break_op (0);
+    fail_intersection_operation (op);
+    return;
+  }
+  GNUNET_CONTAINER_bloomfilter_free (op->state->remote_bf);
+  op->state->remote_bf = NULL;
+
+  if ((0 == op->state->my_element_count) ||  /* fully disjoint */
+      ((op->state->my_element_count == op->remote_element_count) &&
+       (0 == GNUNET_memcmp (&op->state->my_xor,
+                            &op->state->other_xor))))
+  {
+    /* we are done */
+    op->state->phase = PHASE_MUST_SEND_DONE;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Intersection succeeded, sending DONE to other peer\n");
+    GNUNET_CONTAINER_bloomfilter_free (op->state->local_bf);
+    op->state->local_bf = NULL;
+    if (GNUNET_SET_RESULT_FULL == op->result_mode)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Sending full result set (%u elements)\n",
+                  GNUNET_CONTAINER_multihashmap_size (op->state->my_elements));
+      op->state->full_result_iter
+        = GNUNET_CONTAINER_multihashmap_iterator_create (
+            op->state->my_elements);
+      send_remaining_elements (op);
+      return;
+    }
+    send_p2p_done (op);
+    return;
+  }
+  op->state->phase = PHASE_BF_EXCHANGE;
+  send_bloomfilter (op);
+}
+
+
+/**
+ * Check an BF message from a remote peer.
+ *
+ * @param cls the intersection operation
+ * @param msg the header of the message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+int
+check_intersection_p2p_bf (void *cls,
+                           const struct BFMessage *msg)
+{
+  struct Operation *op = cls;
+
+  if (GNUNET_SET_OPERATION_INTERSECTION != op->set->operation)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle an BF message from a remote peer.
+ *
+ * @param cls the intersection operation
+ * @param msg the header of the message
+ */
+void
+handle_intersection_p2p_bf (void *cls,
+                            const struct BFMessage *msg)
+{
+  struct Operation *op = cls;
+  uint32_t bf_size;
+  uint32_t chunk_size;
+  uint32_t bf_bits_per_element;
+
+  switch (op->state->phase)
+  {
+  case PHASE_INITIAL:
+    GNUNET_break_op (0);
+    fail_intersection_operation (op);
+    return;
+
+  case PHASE_COUNT_SENT:
+  case PHASE_BF_EXCHANGE:
+    bf_size = ntohl (msg->bloomfilter_total_length);
+    bf_bits_per_element = ntohl (msg->bits_per_element);
+    chunk_size = htons (msg->header.size) - sizeof(struct BFMessage);
+    op->state->other_xor = msg->element_xor_hash;
+    if (bf_size == chunk_size)
+    {
+      if (NULL != op->state->bf_data)
+      {
+        GNUNET_break_op (0);
+        fail_intersection_operation (op);
+        return;
+      }
+      /* single part, done here immediately */
+      op->state->remote_bf
+        = GNUNET_CONTAINER_bloomfilter_init ((const char *) &msg[1],
+                                             bf_size,
+                                             bf_bits_per_element);
+      op->state->salt = ntohl (msg->sender_mutator);
+      op->remote_element_count = ntohl (msg->sender_element_count);
+      process_bf (op);
+      break;
+    }
+    /* multipart chunk */
+    if (NULL == op->state->bf_data)
+    {
+      /* first chunk, initialize */
+      op->state->bf_data = GNUNET_malloc (bf_size);
+      op->state->bf_data_size = bf_size;
+      op->state->bf_bits_per_element = bf_bits_per_element;
+      op->state->bf_data_offset = 0;
+      op->state->salt = ntohl (msg->sender_mutator);
+      op->remote_element_count = ntohl (msg->sender_element_count);
+    }
+    else
+    {
+      /* increment */
+      if ((op->state->bf_data_size != bf_size) ||
+          (op->state->bf_bits_per_element != bf_bits_per_element) ||
+          (op->state->bf_data_offset + chunk_size > bf_size) ||
+          (op->state->salt != ntohl (msg->sender_mutator)) ||
+          (op->remote_element_count != ntohl (msg->sender_element_count)))
+      {
+        GNUNET_break_op (0);
+        fail_intersection_operation (op);
+        return;
+      }
+    }
+    GNUNET_memcpy (&op->state->bf_data[op->state->bf_data_offset],
+                   (const char *) &msg[1],
+                   chunk_size);
+    op->state->bf_data_offset += chunk_size;
+    if (op->state->bf_data_offset == bf_size)
+    {
+      /* last chunk, run! */
+      op->state->remote_bf
+        = GNUNET_CONTAINER_bloomfilter_init (op->state->bf_data,
+                                             bf_size,
+                                             bf_bits_per_element);
+      GNUNET_free (op->state->bf_data);
+      op->state->bf_data = NULL;
+      op->state->bf_data_size = 0;
+      process_bf (op);
+    }
+    break;
+
+  default:
+    GNUNET_break_op (0);
+    fail_intersection_operation (op);
+    return;
+  }
+  GNUNET_CADET_receive_done (op->channel);
+}
+
+
+/**
+ * Remove all elements from our hashmap.
+ *
+ * @param cls closure with the `struct Operation *`
+ * @param key current key code
+ * @param value value in the hash map
+ * @return #GNUNET_YES (we should continue to iterate)
+ */
+static int
+filter_all (void *cls,
+            const struct GNUNET_HashCode *key,
+            void *value)
+{
+  struct Operation *op = cls;
+  struct ElementEntry *ee = value;
+
+  GNUNET_break (0 < op->state->my_element_count);
+  op->state->my_element_count--;
+  GNUNET_CRYPTO_hash_xor (&op->state->my_xor,
+                          &ee->element_hash,
+                          &op->state->my_xor);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Final reduction of my_elements, removing %s:%u\n",
+              GNUNET_h2s (&ee->element_hash),
+              ee->element.size);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_remove (op->state->my_elements,
+                                                       &ee->element_hash,
+                                                       ee));
+  send_client_removed_element (op,
+                               &ee->element);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Handle a done message from a remote peer
+ *
+ * @param cls the intersection operation
+ * @param idm the message
+ */
+void
+handle_intersection_p2p_done (void *cls,
+                              const struct IntersectionDoneMessage *idm)
+{
+  struct Operation *op = cls;
+
+  if (GNUNET_SET_OPERATION_INTERSECTION != op->set->operation)
+  {
+    GNUNET_break_op (0);
+    fail_intersection_operation (op);
+    return;
+  }
+  if (PHASE_BF_EXCHANGE != op->state->phase)
+  {
+    /* wrong phase to conclude? FIXME: Or should we allow this
+       if the other peer has _initially_ already an empty set? */
+    GNUNET_break_op (0);
+    fail_intersection_operation (op);
+    return;
+  }
+  if (0 == ntohl (idm->final_element_count))
+  {
+    /* other peer determined empty set is the intersection,
+       remove all elements */
+    GNUNET_CONTAINER_multihashmap_iterate (op->state->my_elements,
+                                           &filter_all,
+                                           op);
+  }
+  if ((op->state->my_element_count != ntohl (idm->final_element_count)) ||
+      (0 != GNUNET_memcmp (&op->state->my_xor,
+                           &idm->element_xor_hash)))
+  {
+    /* Other peer thinks we are done, but we disagree on the result! */
+    GNUNET_break_op (0);
+    fail_intersection_operation (op);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Got IntersectionDoneMessage, have %u elements in intersection\n",
+              op->state->my_element_count);
+  op->state->phase = PHASE_DONE_RECEIVED;
+  GNUNET_CADET_receive_done (op->channel);
+
+  GNUNET_assert (GNUNET_NO == op->state->client_done_sent);
+  if (GNUNET_SET_RESULT_FULL == op->result_mode)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending full result set to client (%u elements)\n",
+                GNUNET_CONTAINER_multihashmap_size (op->state->my_elements));
+    op->state->full_result_iter
+      = GNUNET_CONTAINER_multihashmap_iterator_create (op->state->my_elements);
+    send_remaining_elements (op);
+    return;
+  }
+  op->state->phase = PHASE_FINISHED;
+  send_client_done_and_destroy (op);
+}
+
+
+/**
+ * Initiate a set intersection operation with a remote peer.
+ *
+ * @param op operation that is created, should be initialized to
+ *        begin the evaluation
+ * @param opaque_context message to be transmitted to the listener
+ *        to convince it to accept, may be NULL
+ * @return operation-specific state to keep in @a op
+ */
+static struct OperationState *
+intersection_evaluate (struct Operation *op,
+                       const struct GNUNET_MessageHeader *opaque_context)
+{
+  struct OperationState *state;
+  struct GNUNET_MQ_Envelope *ev;
+  struct OperationRequestMessage *msg;
+
+  ev = GNUNET_MQ_msg_nested_mh (msg,
+                                GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST,
+                                opaque_context);
+  if (NULL == ev)
+  {
+    /* the context message is too large!? */
+    GNUNET_break (0);
+    return NULL;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Initiating intersection operation evaluation\n");
+  state = GNUNET_new (struct OperationState);
+  /* we started the operation, thus we have to send the operation request */
+  state->phase = PHASE_INITIAL;
+  state->my_element_count = op->set->state->current_set_element_count;
+  state->my_elements
+    = GNUNET_CONTAINER_multihashmap_create (state->my_element_count,
+                                            GNUNET_YES);
+
+  msg->operation = htonl (GNUNET_SET_OPERATION_INTERSECTION);
+  msg->element_count = htonl (state->my_element_count);
+  GNUNET_MQ_send (op->mq,
+                  ev);
+  state->phase = PHASE_COUNT_SENT;
+  if (NULL != opaque_context)
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sent op request with context message\n");
+  else
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sent op request without context message\n");
+  return state;
+}
+
+
+/**
+ * Accept an intersection operation request from a remote peer.  Only
+ * initializes the private operation state.
+ *
+ * @param op operation that will be accepted as an intersection operation
+ */
+static struct OperationState *
+intersection_accept (struct Operation *op)
+{
+  struct OperationState *state;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Accepting set intersection operation\n");
+  state = GNUNET_new (struct OperationState);
+  state->phase = PHASE_INITIAL;
+  state->my_element_count
+    = op->set->state->current_set_element_count;
+  state->my_elements
+    = GNUNET_CONTAINER_multihashmap_create (GNUNET_MIN (state->my_element_count,
+                                                        op->remote_element_count),
+                                            GNUNET_YES);
+  op->state = state;
+  if (op->remote_element_count < state->my_element_count)
+  {
+    /* If the other peer (Alice) has fewer elements than us (Bob),
+       we just send the count as Alice should send the first BF */
+    send_element_count (op);
+    state->phase = PHASE_COUNT_SENT;
+    return state;
+  }
+  /* We have fewer elements, so we start with the BF */
+  begin_bf_exchange (op);
+  return state;
+}
+
+
+/**
+ * Destroy the intersection operation.  Only things specific to the
+ * intersection operation are destroyed.
+ *
+ * @param op intersection operation to destroy
+ */
+static void
+intersection_op_cancel (struct Operation *op)
+{
+  /* check if the op was canceled twice */
+  GNUNET_assert (NULL != op->state);
+  if (NULL != op->state->remote_bf)
+  {
+    GNUNET_CONTAINER_bloomfilter_free (op->state->remote_bf);
+    op->state->remote_bf = NULL;
+  }
+  if (NULL != op->state->local_bf)
+  {
+    GNUNET_CONTAINER_bloomfilter_free (op->state->local_bf);
+    op->state->local_bf = NULL;
+  }
+  if (NULL != op->state->my_elements)
+  {
+    GNUNET_CONTAINER_multihashmap_destroy (op->state->my_elements);
+    op->state->my_elements = NULL;
+  }
+  if (NULL != op->state->full_result_iter)
+  {
+    GNUNET_CONTAINER_multihashmap_iterator_destroy (
+      op->state->full_result_iter);
+    op->state->full_result_iter = NULL;
+  }
+  GNUNET_free (op->state);
+  op->state = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Destroying intersection op state done\n");
+}
+
+
+/**
+ * Create a new set supporting the intersection operation.
+ *
+ * @return the newly created set
+ */
+static struct SetState *
+intersection_set_create ()
+{
+  struct SetState *set_state;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Intersection set created\n");
+  set_state = GNUNET_new (struct SetState);
+  set_state->current_set_element_count = 0;
+
+  return set_state;
+}
+
+
+/**
+ * Add the element from the given element message to the set.
+ *
+ * @param set_state state of the set want to add to
+ * @param ee the element to add to the set
+ */
+static void
+intersection_add (struct SetState *set_state,
+                  struct ElementEntry *ee)
+{
+  set_state->current_set_element_count++;
+}
+
+
+/**
+ * Destroy a set that supports the intersection operation
+ *
+ * @param set_state the set to destroy
+ */
+static void
+intersection_set_destroy (struct SetState *set_state)
+{
+  GNUNET_free (set_state);
+}
+
+
+/**
+ * Remove the element given in the element message from the set.
+ *
+ * @param set_state state of the set to remove from
+ * @param element set element to remove
+ */
+static void
+intersection_remove (struct SetState *set_state,
+                     struct ElementEntry *element)
+{
+  GNUNET_assert (0 < set_state->current_set_element_count);
+  set_state->current_set_element_count--;
+}
+
+
+/**
+ * Callback for channel death for the intersection operation.
+ *
+ * @param op operation that lost the channel
+ */
+static void
+intersection_channel_death (struct Operation *op)
+{
+  if (GNUNET_YES == op->state->channel_death_expected)
+  {
+    /* oh goodie, we are done! */
+    send_client_done_and_destroy (op);
+  }
+  else
+  {
+    /* sorry, channel went down early, too bad. */
+    _GSS_operation_destroy (op,
+                            GNUNET_YES);
+  }
+}
+
+
+/**
+ * Get the table with implementing functions for set intersection.
+ *
+ * @return the operation specific VTable
+ */
+const struct SetVT *
+_GSS_intersection_vt ()
+{
+  static const struct SetVT intersection_vt = {
+    .create = &intersection_set_create,
+    .add = &intersection_add,
+    .remove = &intersection_remove,
+    .destroy_set = &intersection_set_destroy,
+    .evaluate = &intersection_evaluate,
+    .accept = &intersection_accept,
+    .cancel = &intersection_op_cancel,
+    .channel_death = &intersection_channel_death,
+  };
+
+  return &intersection_vt;
+}
diff --git a/src/contrib/service/set/gnunet-service-set_intersection.h b/src/contrib/service/set/gnunet-service-set_intersection.h
new file mode 100644
index 000000000..d8884d0a7
--- /dev/null
+++ b/src/contrib/service/set/gnunet-service-set_intersection.h
@@ -0,0 +1,79 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2013-2017 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file set/gnunet-service-set_intersection.h
+ * @brief two-peer set operations
+ * @author Florian Dold
+ * @author Christian Grothoff
+ */
+#ifndef GNUNET_SERVICE_SET_INTERSECTION_H
+#define GNUNET_SERVICE_SET_INTERSECTION_H
+
+#include "gnunet-service-set.h"
+
+
+/**
+ * Check an BF message from a remote peer.
+ *
+ * @param cls the intersection operation
+ * @param msg the header of the message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+int
+check_intersection_p2p_bf (void *cls,
+                           const struct BFMessage *msg);
+
+
+/**
+ * Handle an BF message from a remote peer.
+ *
+ * @param cls the intersection operation
+ * @param msg the header of the message
+ */
+void
+handle_intersection_p2p_bf (void *cls,
+                            const struct BFMessage *msg);
+
+
+/**
+ * Handle the initial `struct IntersectionElementInfoMessage` from a
+ * remote peer.
+ *
+ * @param cls the intersection operation
+ * @param msg the header of the message
+ */
+void
+handle_intersection_p2p_element_info (void *cls,
+                                      const struct
+                                      IntersectionElementInfoMessage *msg);
+
+
+/**
+ * Handle a done message from a remote peer
+ *
+ * @param cls the intersection operation
+ * @param mh the message
+ */
+void
+handle_intersection_p2p_done (void *cls,
+                              const struct IntersectionDoneMessage *idm);
+
+
+#endif
diff --git a/src/contrib/service/set/gnunet-service-set_protocol.h b/src/contrib/service/set/gnunet-service-set_protocol.h
new file mode 100644
index 000000000..a2803ee47
--- /dev/null
+++ b/src/contrib/service/set/gnunet-service-set_protocol.h
@@ -0,0 +1,226 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2013, 2014 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 Florian Dold
+ * @author Christian Grothoff
+ * @file set/gnunet-service-set_protocol.h
+ * @brief Peer-to-Peer messages for gnunet set
+ */
+#ifndef SET_PROTOCOL_H
+#define SET_PROTOCOL_H
+
+#include "platform.h"
+#include "gnunet_common.h"
+
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+struct OperationRequestMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Operation to request, values from `enum GNUNET_SET_OperationType`
+   */
+  uint32_t operation GNUNET_PACKED;
+
+  /**
+   * For Intersection: my element count
+   */
+  uint32_t element_count GNUNET_PACKED;
+
+  /**
+   * Application-specific identifier of the request.
+   */
+  struct GNUNET_HashCode app_idX;
+
+  /* rest: optional message */
+};
+
+
+/**
+ * Message containing buckets of an invertible bloom filter.
+ *
+ * If an IBF has too many buckets for an IBF message,
+ * it is split into multiple messages.
+ */
+struct IBFMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Order of the whole ibf, where
+   * num_buckets = 2^order
+   */
+  uint8_t order;
+
+  /**
+   * Padding, must be 0.
+   */
+  uint8_t reserved1;
+
+  /**
+   * Padding, must be 0.
+   */
+  uint16_t reserved2 GNUNET_PACKED;
+
+  /**
+   * Offset of the strata in the rest of the message
+   */
+  uint32_t offset GNUNET_PACKED;
+
+  /**
+   * Salt used when hashing elements for this IBF.
+   */
+  uint32_t salt GNUNET_PACKED;
+
+  /* rest: buckets */
+};
+
+
+struct InquiryMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Salt used when hashing elements for this inquiry.
+   */
+  uint32_t salt GNUNET_PACKED;
+
+  /**
+   * Reserved, set to 0.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /* rest: inquiry IBF keys */
+};
+
+
+/**
+ * During intersection, the first (and possibly second) message
+ * send it the number of elements in the set, to allow the peers
+ * to decide who should start with the Bloom filter.
+ */
+struct IntersectionElementInfoMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_ELEMENT_INFO
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * mutator used with this bloomfilter.
+   */
+  uint32_t sender_element_count GNUNET_PACKED;
+};
+
+
+/**
+ * Bloom filter messages exchanged for set intersection calculation.
+ */
+struct BFMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_BF
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Number of elements the sender still has in the set.
+   */
+  uint32_t sender_element_count GNUNET_PACKED;
+
+  /**
+   * XOR of all hashes over all elements remaining in the set.
+   * Used to determine termination.
+   */
+  struct GNUNET_HashCode element_xor_hash;
+
+  /**
+   * Mutator used with this bloomfilter.
+   */
+  uint32_t sender_mutator GNUNET_PACKED;
+
+  /**
+   * Total length of the bloomfilter data.
+   */
+  uint32_t bloomfilter_total_length GNUNET_PACKED;
+
+  /**
+   * Number of bits (k-value) used in encoding the bloomfilter.
+   */
+  uint32_t bits_per_element GNUNET_PACKED;
+
+  /**
+   * rest: the sender's bloomfilter
+   */
+};
+
+
+/**
+ * Last message, send to confirm the final set.  Contains the element
+ * count as it is possible that the peer determined that we were done
+ * by getting the empty set, which in that case also needs to be
+ * communicated.
+ */
+struct IntersectionDoneMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_INTERSECTION_P2P_DONE
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Final number of elements in intersection.
+   */
+  uint32_t final_element_count GNUNET_PACKED;
+
+  /**
+   * XOR of all hashes over all elements remaining in the set.
+   */
+  struct GNUNET_HashCode element_xor_hash;
+};
+
+
+/**
+ * Strata estimator together with the peer's overall set size.
+ */
+struct StrataEstimatorMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE(C)
+   */
+  struct GNUNET_MessageHeader header;
+
+  uint64_t set_size;
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+#endif
diff --git a/src/contrib/service/set/gnunet-service-set_union.c b/src/contrib/service/set/gnunet-service-set_union.c
new file mode 100644
index 000000000..3a2bc8bd7
--- /dev/null
+++ b/src/contrib/service/set/gnunet-service-set_union.c
@@ -0,0 +1,2463 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2013-2017 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file set/gnunet-service-set_union.c
+ * @brief two-peer set operations
+ * @author Florian Dold
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_statistics_service.h"
+#include "gnunet-service-set.h"
+#include "ibf.h"
+#include "gnunet-service-set_union.h"
+#include "gnunet-service-set_union_strata_estimator.h"
+#include "gnunet-service-set_protocol.h"
+#include <gcrypt.h>
+
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "set-union", __VA_ARGS__)
+
+
+/**
+ * Number of IBFs in a strata estimator.
+ */
+#define SE_STRATA_COUNT 32
+
+/**
+ * Size of the IBFs in the strata estimator.
+ */
+#define SE_IBF_SIZE 80
+
+/**
+ * The hash num parameter for the difference digests and strata estimators.
+ */
+#define SE_IBF_HASH_NUM 4
+
+/**
+ * Number of buckets that can be transmitted in one message.
+ */
+#define MAX_BUCKETS_PER_MESSAGE ((1 << 15) / IBF_BUCKET_SIZE)
+
+/**
+ * The maximum size of an ibf we use is 2^(MAX_IBF_ORDER).
+ * Choose this value so that computing the IBF is still cheaper
+ * than transmitting all values.
+ */
+#define MAX_IBF_ORDER (20)
+
+/**
+ * Number of buckets used in the ibf per estimated
+ * difference.
+ */
+#define IBF_ALPHA 4
+
+
+/**
+ * Current phase we are in for a union operation.
+ */
+enum UnionOperationPhase
+{
+  /**
+   * We sent the request message, and expect a strata estimator.
+   */
+  PHASE_EXPECT_SE,
+
+  /**
+   * We sent the strata estimator, and expect an IBF. This phase is entered once
+   * upon initialization and later via #PHASE_EXPECT_ELEMENTS_AND_REQUESTS.
+   *
+   * XXX: could use better wording.
+   * XXX: repurposed to also expect a "request full set" message, should be renamed
+   *
+   * After receiving the complete IBF, we enter #PHASE_EXPECT_ELEMENTS
+   */
+  PHASE_EXPECT_IBF,
+
+  /**
+   * Continuation for multi part IBFs.
+   */
+  PHASE_EXPECT_IBF_CONT,
+
+  /**
+   * We are decoding an IBF.
+   */
+  PHASE_INVENTORY_ACTIVE,
+
+  /**
+   * The other peer is decoding the IBF we just sent.
+   */
+  PHASE_INVENTORY_PASSIVE,
+
+  /**
+   * The protocol is almost finished, but we still have to flush our message
+   * queue and/or expect some elements.
+   */
+  PHASE_FINISH_CLOSING,
+
+  /**
+   * In the penultimate phase,
+   * we wait until all our demands
+   * are satisfied.  Then we send a done
+   * message, and wait for another done message.
+   */
+  PHASE_FINISH_WAITING,
+
+  /**
+   * In the ultimate phase, we wait until
+   * our demands are satisfied and then
+   * quit (sending another DONE message).
+   */
+  PHASE_DONE,
+
+  /**
+   * After sending the full set, wait for responses with the elements
+   * that the local peer is missing.
+   */
+  PHASE_FULL_SENDING,
+};
+
+
+/**
+ * State of an evaluate operation with another peer.
+ */
+struct OperationState
+{
+  /**
+   * Copy of the set's strata estimator at the time of
+   * creation of this operation.
+   */
+  struct StrataEstimator *se;
+
+  /**
+   * The IBF we currently receive.
+   */
+  struct InvertibleBloomFilter *remote_ibf;
+
+  /**
+   * The IBF with the local set's element.
+   */
+  struct InvertibleBloomFilter *local_ibf;
+
+  /**
+   * Maps unsalted IBF-Keys to elements.
+   * Used as a multihashmap, the keys being the lower 32bit of the IBF-Key.
+   * Colliding IBF-Keys are linked.
+   */
+  struct GNUNET_CONTAINER_MultiHashMap32 *key_to_element;
+
+  /**
+   * Current state of the operation.
+   */
+  enum UnionOperationPhase phase;
+
+  /**
+   * Did we send the client that we are done?
+   */
+  int client_done_sent;
+
+  /**
+   * Number of ibf buckets already received into the @a remote_ibf.
+   */
+  unsigned int ibf_buckets_received;
+
+  /**
+   * Hashes for elements that we have demanded from the other peer.
+   */
+  struct GNUNET_CONTAINER_MultiHashMap *demanded_hashes;
+
+  /**
+   * Salt that we're using for sending IBFs
+   */
+  uint32_t salt_send;
+
+  /**
+   * Salt for the IBF we've received and that we're currently decoding.
+   */
+  uint32_t salt_receive;
+
+  /**
+   * Number of elements we received from the other peer
+   * that were not in the local set yet.
+   */
+  uint32_t received_fresh;
+
+  /**
+   * Total number of elements received from the other peer.
+   */
+  uint32_t received_total;
+
+  /**
+   * Initial size of our set, just before
+   * the operation started.
+   */
+  uint64_t initial_size;
+};
+
+
+/**
+ * The key entry is used to associate an ibf key with an element.
+ */
+struct KeyEntry
+{
+  /**
+   * IBF key for the entry, derived from the current salt.
+   */
+  struct IBF_Key ibf_key;
+
+  /**
+   * The actual element associated with the key.
+   *
+   * Only owned by the union operation if element->operation
+   * is #GNUNET_YES.
+   */
+  struct ElementEntry *element;
+
+  /**
+   * Did we receive this element?
+   * Even if element->is_foreign is false, we might
+   * have received the element, so this indicates that
+   * the other peer has it.
+   */
+  int received;
+};
+
+
+/**
+ * Used as a closure for sending elements
+ * with a specific IBF key.
+ */
+struct SendElementClosure
+{
+  /**
+   * The IBF key whose matching elements should be
+   * sent.
+   */
+  struct IBF_Key ibf_key;
+
+  /**
+   * Operation for which the elements
+   * should be sent.
+   */
+  struct Operation *op;
+};
+
+
+/**
+ * Extra state required for efficient set union.
+ */
+struct SetState
+{
+  /**
+   * The strata estimator is only generated once for
+   * each set.
+   * The IBF keys are derived from the element hashes with
+   * salt=0.
+   */
+  struct StrataEstimator *se;
+};
+
+
+/**
+ * Iterator over hash map entries, called to
+ * destroy the linked list of colliding ibf key entries.
+ *
+ * @param cls closure
+ * @param key current key code
+ * @param value value in the hash map
+ * @return #GNUNET_YES if we should continue to iterate,
+ *         #GNUNET_NO if not.
+ */
+static int
+destroy_key_to_element_iter (void *cls,
+                             uint32_t key,
+                             void *value)
+{
+  struct KeyEntry *k = value;
+
+  GNUNET_assert (NULL != k);
+  if (GNUNET_YES == k->element->remote)
+  {
+    GNUNET_free (k->element);
+    k->element = NULL;
+  }
+  GNUNET_free (k);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Destroy the union operation.  Only things specific to the union
+ * operation are destroyed.
+ *
+ * @param op union operation to destroy
+ */
+static void
+union_op_cancel (struct Operation *op)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "destroying union op\n");
+  /* check if the op was canceled twice */
+  GNUNET_assert (NULL != op->state);
+  if (NULL != op->state->remote_ibf)
+  {
+    ibf_destroy (op->state->remote_ibf);
+    op->state->remote_ibf = NULL;
+  }
+  if (NULL != op->state->demanded_hashes)
+  {
+    GNUNET_CONTAINER_multihashmap_destroy (op->state->demanded_hashes);
+    op->state->demanded_hashes = NULL;
+  }
+  if (NULL != op->state->local_ibf)
+  {
+    ibf_destroy (op->state->local_ibf);
+    op->state->local_ibf = NULL;
+  }
+  if (NULL != op->state->se)
+  {
+    strata_estimator_destroy (op->state->se);
+    op->state->se = NULL;
+  }
+  if (NULL != op->state->key_to_element)
+  {
+    GNUNET_CONTAINER_multihashmap32_iterate (op->state->key_to_element,
+                                             &destroy_key_to_element_iter,
+                                             NULL);
+    GNUNET_CONTAINER_multihashmap32_destroy (op->state->key_to_element);
+    op->state->key_to_element = NULL;
+  }
+  GNUNET_free (op->state);
+  op->state = NULL;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "destroying union op done\n");
+}
+
+
+/**
+ * Inform the client that the union operation has failed,
+ * and proceed to destroy the evaluate operation.
+ *
+ * @param op the union operation to fail
+ */
+static void
+fail_union_operation (struct Operation *op)
+{
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_SET_ResultMessage *msg;
+
+  LOG (GNUNET_ERROR_TYPE_WARNING,
+       "union operation failed\n");
+  ev = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_SET_RESULT);
+  msg->result_status = htons (GNUNET_SET_STATUS_FAILURE);
+  msg->request_id = htonl (op->client_request_id);
+  msg->element_type = htons (0);
+  GNUNET_MQ_send (op->set->cs->mq,
+                  ev);
+  _GSS_operation_destroy (op, GNUNET_YES);
+}
+
+
+/**
+ * Derive the IBF key from a hash code and
+ * a salt.
+ *
+ * @param src the hash code
+ * @return the derived IBF key
+ */
+static struct IBF_Key
+get_ibf_key (const struct GNUNET_HashCode *src)
+{
+  struct IBF_Key key;
+  uint16_t salt = 0;
+
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CRYPTO_kdf (&key, sizeof(key),
+                                    src, sizeof *src,
+                                    &salt, sizeof(salt),
+                                    NULL, 0));
+  return key;
+}
+
+
+/**
+ * Context for #op_get_element_iterator
+ */
+struct GetElementContext
+{
+  /**
+   * FIXME.
+   */
+  struct GNUNET_HashCode hash;
+
+  /**
+   * FIXME.
+   */
+  struct KeyEntry *k;
+};
+
+
+/**
+ * Iterator over the mapping from IBF keys to element entries.  Checks if we
+ * have an element with a given GNUNET_HashCode.
+ *
+ * @param cls closure
+ * @param key current key code
+ * @param value value in the hash map
+ * @return #GNUNET_YES if we should search further,
+ *         #GNUNET_NO if we've found the element.
+ */
+static int
+op_get_element_iterator (void *cls,
+                         uint32_t key,
+                         void *value)
+{
+  struct GetElementContext *ctx = cls;
+  struct KeyEntry *k = value;
+
+  GNUNET_assert (NULL != k);
+  if (0 == GNUNET_CRYPTO_hash_cmp (&k->element->element_hash,
+                                   &ctx->hash))
+  {
+    ctx->k = k;
+    return GNUNET_NO;
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * Determine whether the given element is already in the operation's element
+ * set.
+ *
+ * @param op operation that should be tested for 'element_hash'
+ * @param element_hash hash of the element to look for
+ * @return #GNUNET_YES if the element has been found, #GNUNET_NO otherwise
+ */
+static struct KeyEntry *
+op_get_element (struct Operation *op,
+                const struct GNUNET_HashCode *element_hash)
+{
+  int ret;
+  struct IBF_Key ibf_key;
+  struct GetElementContext ctx = { { { 0 } }, 0 };
+
+  ctx.hash = *element_hash;
+
+  ibf_key = get_ibf_key (element_hash);
+  ret = GNUNET_CONTAINER_multihashmap32_get_multiple (op->state->key_to_element,
+                                                      (uint32_t) ibf_key.key_val,
+                                                      op_get_element_iterator,
+                                                      &ctx);
+
+  /* was the iteration aborted because we found the element? */
+  if (GNUNET_SYSERR == ret)
+  {
+    GNUNET_assert (NULL != ctx.k);
+    return ctx.k;
+  }
+  return NULL;
+}
+
+
+/**
+ * Insert an element into the union operation's
+ * key-to-element mapping. Takes ownership of 'ee'.
+ * Note that this does not insert the element in the set,
+ * only in the operation's key-element mapping.
+ * This is done to speed up re-tried operations, if some elements
+ * were transmitted, and then the IBF fails to decode.
+ *
+ * XXX: clarify ownership, doesn't sound right.
+ *
+ * @param op the union operation
+ * @param ee the element entry
+ * @param received was this element received from the remote peer?
+ */
+static void
+op_register_element (struct Operation *op,
+                     struct ElementEntry *ee,
+                     int received)
+{
+  struct IBF_Key ibf_key;
+  struct KeyEntry *k;
+
+  ibf_key = get_ibf_key (&ee->element_hash);
+  k = GNUNET_new (struct KeyEntry);
+  k->element = ee;
+  k->ibf_key = ibf_key;
+  k->received = received;
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multihashmap32_put (op->state->key_to_element,
+                                                      (uint32_t) ibf_key.key_val,
+                                                      k,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+}
+
+
+/**
+ * FIXME.
+ */
+static void
+salt_key (const struct IBF_Key *k_in,
+          uint32_t salt,
+          struct IBF_Key *k_out)
+{
+  int s = salt % 64;
+  uint64_t x = k_in->key_val;
+
+  /* rotate ibf key */
+  x = (x >> s) | (x << (64 - s));
+  k_out->key_val = x;
+}
+
+
+/**
+ * FIXME.
+ */
+static void
+unsalt_key (const struct IBF_Key *k_in,
+            uint32_t salt,
+            struct IBF_Key *k_out)
+{
+  int s = salt % 64;
+  uint64_t x = k_in->key_val;
+
+  x = (x << s) | (x >> (64 - s));
+  k_out->key_val = x;
+}
+
+
+/**
+ * Insert a key into an ibf.
+ *
+ * @param cls the ibf
+ * @param key unused
+ * @param value the key entry to get the key from
+ */
+static int
+prepare_ibf_iterator (void *cls,
+                      uint32_t key,
+                      void *value)
+{
+  struct Operation *op = cls;
+  struct KeyEntry *ke = value;
+  struct IBF_Key salted_key;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "[OP %p] inserting %lx (hash %s) into ibf\n",
+       op,
+       (unsigned long) ke->ibf_key.key_val,
+       GNUNET_h2s (&ke->element->element_hash));
+  salt_key (&ke->ibf_key,
+            op->state->salt_send,
+            &salted_key);
+  ibf_insert (op->state->local_ibf, salted_key);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Iterator for initializing the
+ * key-to-element mapping of a union operation
+ *
+ * @param cls the union operation `struct Operation *`
+ * @param key unused
+ * @param value the `struct ElementEntry *` to insert
+ *        into the key-to-element mapping
+ * @return #GNUNET_YES (to continue iterating)
+ */
+static int
+init_key_to_element_iterator (void *cls,
+                              const struct GNUNET_HashCode *key,
+                              void *value)
+{
+  struct Operation *op = cls;
+  struct ElementEntry *ee = value;
+
+  /* make sure that the element belongs to the set at the time
+   * of creating the operation */
+  if (GNUNET_NO ==
+      _GSS_is_element_of_operation (ee,
+                                    op))
+    return GNUNET_YES;
+  GNUNET_assert (GNUNET_NO == ee->remote);
+  op_register_element (op,
+                       ee,
+                       GNUNET_NO);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Initialize the IBF key to element mapping local to this set
+ * operation.
+ *
+ * @param op the set union operation
+ */
+static void
+initialize_key_to_element (struct Operation *op)
+{
+  unsigned int len;
+
+  GNUNET_assert (NULL == op->state->key_to_element);
+  len = GNUNET_CONTAINER_multihashmap_size (op->set->content->elements);
+  op->state->key_to_element = GNUNET_CONTAINER_multihashmap32_create (len + 1);
+  GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements,
+                                         &init_key_to_element_iterator,
+                                         op);
+}
+
+
+/**
+ * Create an ibf with the operation's elements
+ * of the specified size
+ *
+ * @param op the union operation
+ * @param size size of the ibf to create
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
+ */
+static int
+prepare_ibf (struct Operation *op,
+             uint32_t size)
+{
+  GNUNET_assert (NULL != op->state->key_to_element);
+
+  if (NULL != op->state->local_ibf)
+    ibf_destroy (op->state->local_ibf);
+  op->state->local_ibf = ibf_create (size, SE_IBF_HASH_NUM);
+  if (NULL == op->state->local_ibf)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to allocate local IBF\n");
+    return GNUNET_SYSERR;
+  }
+  GNUNET_CONTAINER_multihashmap32_iterate (op->state->key_to_element,
+                                           &prepare_ibf_iterator,
+                                           op);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Send an ibf of appropriate size.
+ *
+ * Fragments the IBF into multiple messages if necessary.
+ *
+ * @param op the union operation
+ * @param ibf_order order of the ibf to send, size=2^order
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
+ */
+static int
+send_ibf (struct Operation *op,
+          uint16_t ibf_order)
+{
+  unsigned int buckets_sent = 0;
+  struct InvertibleBloomFilter *ibf;
+
+  if (GNUNET_OK !=
+      prepare_ibf (op, 1 << ibf_order))
+  {
+    /* allocation failed */
+    return GNUNET_SYSERR;
+  }
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "sending ibf of size %u\n",
+       1 << ibf_order);
+
+  {
+    char name[64] = { 0 };
+    snprintf (name, sizeof(name), "# sent IBF (order %u)", ibf_order);
+    GNUNET_STATISTICS_update (_GSS_statistics, name, 1, GNUNET_NO);
+  }
+
+  ibf = op->state->local_ibf;
+
+  while (buckets_sent < (1 << ibf_order))
+  {
+    unsigned int buckets_in_message;
+    struct GNUNET_MQ_Envelope *ev;
+    struct IBFMessage *msg;
+
+    buckets_in_message = (1 << ibf_order) - buckets_sent;
+    /* limit to maximum */
+    if (buckets_in_message > MAX_BUCKETS_PER_MESSAGE)
+      buckets_in_message = MAX_BUCKETS_PER_MESSAGE;
+
+    ev = GNUNET_MQ_msg_extra (msg,
+                              buckets_in_message * IBF_BUCKET_SIZE,
+                              GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF);
+    msg->reserved1 = 0;
+    msg->reserved2 = 0;
+    msg->order = ibf_order;
+    msg->offset = htonl (buckets_sent);
+    msg->salt = htonl (op->state->salt_send);
+    ibf_write_slice (ibf, buckets_sent,
+                     buckets_in_message, &msg[1]);
+    buckets_sent += buckets_in_message;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "ibf chunk size %u, %u/%u sent\n",
+         buckets_in_message,
+         buckets_sent,
+         1 << ibf_order);
+    GNUNET_MQ_send (op->mq, ev);
+  }
+
+  /* The other peer must decode the IBF, so
+   * we're passive. */
+  op->state->phase = PHASE_INVENTORY_PASSIVE;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Compute the necessary order of an ibf
+ * from the size of the symmetric set difference.
+ *
+ * @param diff the difference
+ * @return the required size of the ibf
+ */
+static unsigned int
+get_order_from_difference (unsigned int diff)
+{
+  unsigned int ibf_order;
+
+  ibf_order = 2;
+  while (((1 << ibf_order) < (IBF_ALPHA * diff) ||
+          ((1 << ibf_order) < SE_IBF_HASH_NUM)) &&
+         (ibf_order < MAX_IBF_ORDER))
+    ibf_order++;
+  // add one for correction
+  return ibf_order + 1;
+}
+
+
+/**
+ * Send a set element.
+ *
+ * @param cls the union operation `struct Operation *`
+ * @param key unused
+ * @param value the `struct ElementEntry *` to insert
+ *        into the key-to-element mapping
+ * @return #GNUNET_YES (to continue iterating)
+ */
+static int
+send_full_element_iterator (void *cls,
+                            const struct GNUNET_HashCode *key,
+                            void *value)
+{
+  struct Operation *op = cls;
+  struct GNUNET_SET_ElementMessage *emsg;
+  struct ElementEntry *ee = value;
+  struct GNUNET_SET_Element *el = &ee->element;
+  struct GNUNET_MQ_Envelope *ev;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Sending element %s\n",
+       GNUNET_h2s (key));
+  ev = GNUNET_MQ_msg_extra (emsg,
+                            el->size,
+                            GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_ELEMENT);
+  emsg->element_type = htons (el->element_type);
+  GNUNET_memcpy (&emsg[1],
+                 el->data,
+                 el->size);
+  GNUNET_MQ_send (op->mq,
+                  ev);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Switch to full set transmission for @a op.
+ *
+ * @param op operation to switch to full set transmission.
+ */
+static void
+send_full_set (struct Operation *op)
+{
+  struct GNUNET_MQ_Envelope *ev;
+
+  op->state->phase = PHASE_FULL_SENDING;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Dedicing to transmit the full set\n");
+  /* FIXME: use a more memory-friendly way of doing this with an
+     iterator, just as we do in the non-full case! */
+  (void) GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements,
+                                                &send_full_element_iterator,
+                                                op);
+  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_DONE);
+  GNUNET_MQ_send (op->mq,
+                  ev);
+}
+
+
+/**
+ * Handle a strata estimator from a remote peer
+ *
+ * @param cls the union operation
+ * @param msg the message
+ */
+int
+check_union_p2p_strata_estimator (void *cls,
+                                  const struct StrataEstimatorMessage *msg)
+{
+  struct Operation *op = cls;
+  int is_compressed;
+  size_t len;
+
+  if (op->state->phase != PHASE_EXPECT_SE)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  is_compressed = (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC == htons (
+                     msg->header.type));
+  len = ntohs (msg->header.size) - sizeof(struct StrataEstimatorMessage);
+  if ((GNUNET_NO == is_compressed) &&
+      (len != SE_STRATA_COUNT * SE_IBF_SIZE * IBF_BUCKET_SIZE))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle a strata estimator from a remote peer
+ *
+ * @param cls the union operation
+ * @param msg the message
+ */
+void
+handle_union_p2p_strata_estimator (void *cls,
+                                   const struct StrataEstimatorMessage *msg)
+{
+  struct Operation *op = cls;
+  struct StrataEstimator *remote_se;
+  unsigned int diff;
+  uint64_t other_size;
+  size_t len;
+  int is_compressed;
+
+  is_compressed = (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC == htons (
+                     msg->header.type));
+  GNUNET_STATISTICS_update (_GSS_statistics,
+                            "# bytes of SE received",
+                            ntohs (msg->header.size),
+                            GNUNET_NO);
+  len = ntohs (msg->header.size) - sizeof(struct StrataEstimatorMessage);
+  other_size = GNUNET_ntohll (msg->set_size);
+  remote_se = strata_estimator_create (SE_STRATA_COUNT,
+                                       SE_IBF_SIZE,
+                                       SE_IBF_HASH_NUM);
+  if (NULL == remote_se)
+  {
+    /* insufficient resources, fail */
+    fail_union_operation (op);
+    return;
+  }
+  if (GNUNET_OK !=
+      strata_estimator_read (&msg[1],
+                             len,
+                             is_compressed,
+                             remote_se))
+  {
+    /* decompression failed */
+    strata_estimator_destroy (remote_se);
+    fail_union_operation (op);
+    return;
+  }
+  GNUNET_assert (NULL != op->state->se);
+  diff = strata_estimator_difference (remote_se,
+                                      op->state->se);
+
+  if (diff > 200)
+    diff = diff * 3 / 2;
+
+  strata_estimator_destroy (remote_se);
+  strata_estimator_destroy (op->state->se);
+  op->state->se = NULL;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "got se diff=%d, using ibf size %d\n",
+       diff,
+       1U << get_order_from_difference (diff));
+
+  {
+    char *set_debug;
+
+    set_debug = getenv ("GNUNET_SET_BENCHMARK");
+    if ((NULL != set_debug) &&
+        (0 == strcmp (set_debug, "1")))
+    {
+      FILE *f = fopen ("set.log", "a");
+      fprintf (f, "%llu\n", (unsigned long long) diff);
+      fclose (f);
+    }
+  }
+
+  if ((GNUNET_YES == op->byzantine) &&
+      (other_size < op->byzantine_lower_bound))
+  {
+    GNUNET_break (0);
+    fail_union_operation (op);
+    return;
+  }
+
+  if ((GNUNET_YES == op->force_full) ||
+      (diff > op->state->initial_size / 4) ||
+      (0 == other_size))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Deciding to go for full set transmission (diff=%d, own set=%llu)\n",
+         diff,
+         (unsigned long long) op->state->initial_size);
+    GNUNET_STATISTICS_update (_GSS_statistics,
+                              "# of full sends",
+                              1,
+                              GNUNET_NO);
+    if ((op->state->initial_size <= other_size) ||
+        (0 == other_size))
+    {
+      send_full_set (op);
+    }
+    else
+    {
+      struct GNUNET_MQ_Envelope *ev;
+
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Telling other peer that we expect its full set\n");
+      op->state->phase = PHASE_EXPECT_IBF;
+      ev = GNUNET_MQ_msg_header (
+        GNUNET_MESSAGE_TYPE_SET_UNION_P2P_REQUEST_FULL);
+      GNUNET_MQ_send (op->mq,
+                      ev);
+    }
+  }
+  else
+  {
+    GNUNET_STATISTICS_update (_GSS_statistics,
+                              "# of ibf sends",
+                              1,
+                              GNUNET_NO);
+    if (GNUNET_OK !=
+        send_ibf (op,
+                  get_order_from_difference (diff)))
+    {
+      /* Internal error, best we can do is shut the connection */
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Failed to send IBF, closing connection\n");
+      fail_union_operation (op);
+      return;
+    }
+  }
+  GNUNET_CADET_receive_done (op->channel);
+}
+
+
+/**
+ * Iterator to send elements to a remote peer
+ *
+ * @param cls closure with the element key and the union operation
+ * @param key ignored
+ * @param value the key entry
+ */
+static int
+send_offers_iterator (void *cls,
+                      uint32_t key,
+                      void *value)
+{
+  struct SendElementClosure *sec = cls;
+  struct Operation *op = sec->op;
+  struct KeyEntry *ke = value;
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_MessageHeader *mh;
+
+  /* Detect 32-bit key collision for the 64-bit IBF keys. */
+  if (ke->ibf_key.key_val != sec->ibf_key.key_val)
+    return GNUNET_YES;
+
+  ev = GNUNET_MQ_msg_header_extra (mh,
+                                   sizeof(struct GNUNET_HashCode),
+                                   GNUNET_MESSAGE_TYPE_SET_UNION_P2P_OFFER);
+
+  GNUNET_assert (NULL != ev);
+  *(struct GNUNET_HashCode *) &mh[1] = ke->element->element_hash;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "[OP %p] sending element offer (%s) to peer\n",
+       op,
+       GNUNET_h2s (&ke->element->element_hash));
+  GNUNET_MQ_send (op->mq, ev);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Send offers (in the form of GNUNET_Hash-es) to the remote peer for the given IBF key.
+ *
+ * @param op union operation
+ * @param ibf_key IBF key of interest
+ */
+static void
+send_offers_for_key (struct Operation *op,
+                     struct IBF_Key ibf_key)
+{
+  struct SendElementClosure send_cls;
+
+  send_cls.ibf_key = ibf_key;
+  send_cls.op = op;
+  (void) GNUNET_CONTAINER_multihashmap32_get_multiple (
+    op->state->key_to_element,
+    (uint32_t) ibf_key.
+    key_val,
+    &send_offers_iterator,
+    &send_cls);
+}
+
+
+/**
+ * Decode which elements are missing on each side, and
+ * send the appropriate offers and inquiries.
+ *
+ * @param op union operation
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
+ */
+static int
+decode_and_send (struct Operation *op)
+{
+  struct IBF_Key key;
+  struct IBF_Key last_key;
+  int side;
+  unsigned int num_decoded;
+  struct InvertibleBloomFilter *diff_ibf;
+
+  GNUNET_assert (PHASE_INVENTORY_ACTIVE == op->state->phase);
+
+  if (GNUNET_OK !=
+      prepare_ibf (op,
+                   op->state->remote_ibf->size))
+  {
+    GNUNET_break (0);
+    /* allocation failed */
+    return GNUNET_SYSERR;
+  }
+  diff_ibf = ibf_dup (op->state->local_ibf);
+  ibf_subtract (diff_ibf,
+                op->state->remote_ibf);
+
+  ibf_destroy (op->state->remote_ibf);
+  op->state->remote_ibf = NULL;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "decoding IBF (size=%u)\n",
+       diff_ibf->size);
+
+  num_decoded = 0;
+  key.key_val = 0; /* just to avoid compiler thinking we use undef'ed variable */
+
+  while (1)
+  {
+    int res;
+    int cycle_detected = GNUNET_NO;
+
+    last_key = key;
+
+    res = ibf_decode (diff_ibf, &side, &key);
+    if (res == GNUNET_OK)
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "decoded ibf key %lx\n",
+           (unsigned long) key.key_val);
+      num_decoded += 1;
+      if ((num_decoded > diff_ibf->size) ||
+          ((num_decoded > 1) &&
+           (last_key.key_val == key.key_val)))
+      {
+        LOG (GNUNET_ERROR_TYPE_DEBUG,
+             "detected cyclic ibf (decoded %u/%u)\n",
+             num_decoded,
+             diff_ibf->size);
+        cycle_detected = GNUNET_YES;
+      }
+    }
+    if ((GNUNET_SYSERR == res) ||
+        (GNUNET_YES == cycle_detected))
+    {
+      int next_order;
+      next_order = 0;
+      while (1 << next_order < diff_ibf->size)
+        next_order++;
+      next_order++;
+      if (next_order <= MAX_IBF_ORDER)
+      {
+        LOG (GNUNET_ERROR_TYPE_DEBUG,
+             "decoding failed, sending larger ibf (size %u)\n",
+             1 << next_order);
+        GNUNET_STATISTICS_update (_GSS_statistics,
+                                  "# of IBF retries",
+                                  1,
+                                  GNUNET_NO);
+        op->state->salt_send++;
+        if (GNUNET_OK !=
+            send_ibf (op, next_order))
+        {
+          /* Internal error, best we can do is shut the connection */
+          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                      "Failed to send IBF, closing connection\n");
+          fail_union_operation (op);
+          ibf_destroy (diff_ibf);
+          return GNUNET_SYSERR;
+        }
+      }
+      else
+      {
+        GNUNET_STATISTICS_update (_GSS_statistics,
+                                  "# of failed union operations (too large)",
+                                  1,
+                                  GNUNET_NO);
+        // XXX: Send the whole set, element-by-element
+        LOG (GNUNET_ERROR_TYPE_ERROR,
+             "set union failed: reached ibf limit\n");
+        fail_union_operation (op);
+        ibf_destroy (diff_ibf);
+        return GNUNET_SYSERR;
+      }
+      break;
+    }
+    if (GNUNET_NO == res)
+    {
+      struct GNUNET_MQ_Envelope *ev;
+
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "transmitted all values, sending DONE\n");
+      ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE);
+      GNUNET_MQ_send (op->mq, ev);
+      /* We now wait until we get a DONE message back
+       * and then wait for our MQ to be flushed and all our
+       * demands be delivered. */
+      break;
+    }
+    if (1 == side)
+    {
+      struct IBF_Key unsalted_key;
+
+      unsalt_key (&key,
+                  op->state->salt_receive,
+                  &unsalted_key);
+      send_offers_for_key (op,
+                           unsalted_key);
+    }
+    else if (-1 == side)
+    {
+      struct GNUNET_MQ_Envelope *ev;
+      struct InquiryMessage *msg;
+
+      /* It may be nice to merge multiple requests, but with CADET's corking it is not worth
+       * the effort additional complexity. */
+      ev = GNUNET_MQ_msg_extra (msg,
+                                sizeof(struct IBF_Key),
+                                GNUNET_MESSAGE_TYPE_SET_UNION_P2P_INQUIRY);
+      msg->salt = htonl (op->state->salt_receive);
+      GNUNET_memcpy (&msg[1],
+                     &key,
+                     sizeof(struct IBF_Key));
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "sending element inquiry for IBF key %lx\n",
+           (unsigned long) key.key_val);
+      GNUNET_MQ_send (op->mq, ev);
+    }
+    else
+    {
+      GNUNET_assert (0);
+    }
+  }
+  ibf_destroy (diff_ibf);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Check an IBF message from a remote peer.
+ *
+ * Reassemble the IBF from multiple pieces, and
+ * process the whole IBF once possible.
+ *
+ * @param cls the union operation
+ * @param msg the header of the message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+int
+check_union_p2p_ibf (void *cls,
+                     const struct IBFMessage *msg)
+{
+  struct Operation *op = cls;
+  unsigned int buckets_in_message;
+
+  if (GNUNET_SET_OPERATION_UNION != op->set->operation)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  buckets_in_message = (ntohs (msg->header.size) - sizeof *msg)
+                       / IBF_BUCKET_SIZE;
+  if (0 == buckets_in_message)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  if ((ntohs (msg->header.size) - sizeof *msg) != buckets_in_message
+      * IBF_BUCKET_SIZE)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  if (op->state->phase == PHASE_EXPECT_IBF_CONT)
+  {
+    if (ntohl (msg->offset) != op->state->ibf_buckets_received)
+    {
+      GNUNET_break_op (0);
+      return GNUNET_SYSERR;
+    }
+    if (1 << msg->order != op->state->remote_ibf->size)
+    {
+      GNUNET_break_op (0);
+      return GNUNET_SYSERR;
+    }
+    if (ntohl (msg->salt) != op->state->salt_receive)
+    {
+      GNUNET_break_op (0);
+      return GNUNET_SYSERR;
+    }
+  }
+  else if ((op->state->phase != PHASE_INVENTORY_PASSIVE) &&
+           (op->state->phase != PHASE_EXPECT_IBF))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle an IBF message from a remote peer.
+ *
+ * Reassemble the IBF from multiple pieces, and
+ * process the whole IBF once possible.
+ *
+ * @param cls the union operation
+ * @param msg the header of the message
+ */
+void
+handle_union_p2p_ibf (void *cls,
+                      const struct IBFMessage *msg)
+{
+  struct Operation *op = cls;
+  unsigned int buckets_in_message;
+
+  buckets_in_message = (ntohs (msg->header.size) - sizeof *msg)
+                       / IBF_BUCKET_SIZE;
+  if ((op->state->phase == PHASE_INVENTORY_PASSIVE) ||
+      (op->state->phase == PHASE_EXPECT_IBF))
+  {
+    op->state->phase = PHASE_EXPECT_IBF_CONT;
+    GNUNET_assert (NULL == op->state->remote_ibf);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Creating new ibf of size %u\n",
+         1 << msg->order);
+    op->state->remote_ibf = ibf_create (1 << msg->order, SE_IBF_HASH_NUM);
+    op->state->salt_receive = ntohl (msg->salt);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Receiving new IBF with salt %u\n",
+         op->state->salt_receive);
+    if (NULL == op->state->remote_ibf)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Failed to parse remote IBF, closing connection\n");
+      fail_union_operation (op);
+      return;
+    }
+    op->state->ibf_buckets_received = 0;
+    if (0 != ntohl (msg->offset))
+    {
+      GNUNET_break_op (0);
+      fail_union_operation (op);
+      return;
+    }
+  }
+  else
+  {
+    GNUNET_assert (op->state->phase == PHASE_EXPECT_IBF_CONT);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Received more of IBF\n");
+  }
+  GNUNET_assert (NULL != op->state->remote_ibf);
+
+  ibf_read_slice (&msg[1],
+                  op->state->ibf_buckets_received,
+                  buckets_in_message,
+                  op->state->remote_ibf);
+  op->state->ibf_buckets_received += buckets_in_message;
+
+  if (op->state->ibf_buckets_received == op->state->remote_ibf->size)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "received full ibf\n");
+    op->state->phase = PHASE_INVENTORY_ACTIVE;
+    if (GNUNET_OK !=
+        decode_and_send (op))
+    {
+      /* Internal error, best we can do is shut down */
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Failed to decode IBF, closing connection\n");
+      fail_union_operation (op);
+      return;
+    }
+  }
+  GNUNET_CADET_receive_done (op->channel);
+}
+
+
+/**
+ * Send a result message to the client indicating
+ * that there is a new element.
+ *
+ * @param op union operation
+ * @param element element to send
+ * @param status status to send with the new element
+ */
+static void
+send_client_element (struct Operation *op,
+                     struct GNUNET_SET_Element *element,
+                     int status)
+{
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_SET_ResultMessage *rm;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "sending element (size %u) to client\n",
+       element->size);
+  GNUNET_assert (0 != op->client_request_id);
+  ev = GNUNET_MQ_msg_extra (rm, element->size, GNUNET_MESSAGE_TYPE_SET_RESULT);
+  if (NULL == ev)
+  {
+    GNUNET_MQ_discard (ev);
+    GNUNET_break (0);
+    return;
+  }
+  rm->result_status = htons (status);
+  rm->request_id = htonl (op->client_request_id);
+  rm->element_type = htons (element->element_type);
+  rm->current_size = GNUNET_htonll (GNUNET_CONTAINER_multihashmap32_size (
+                                      op->state->key_to_element));
+  GNUNET_memcpy (&rm[1],
+                 element->data,
+                 element->size);
+  GNUNET_MQ_send (op->set->cs->mq,
+                  ev);
+}
+
+
+/**
+ * Signal to the client that the operation has finished and
+ * destroy the operation.
+ *
+ * @param cls operation to destroy
+ */
+static void
+send_client_done (void *cls)
+{
+  struct Operation *op = cls;
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_SET_ResultMessage *rm;
+
+  if (GNUNET_YES == op->state->client_done_sent)
+  {
+    return;
+  }
+
+  if (PHASE_DONE != op->state->phase)
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Union operation failed\n");
+    GNUNET_STATISTICS_update (_GSS_statistics,
+                              "# Union operations failed",
+                              1,
+                              GNUNET_NO);
+    ev = GNUNET_MQ_msg (rm, GNUNET_MESSAGE_TYPE_SET_RESULT);
+    rm->result_status = htons (GNUNET_SET_STATUS_FAILURE);
+    rm->request_id = htonl (op->client_request_id);
+    rm->element_type = htons (0);
+    GNUNET_MQ_send (op->set->cs->mq,
+                    ev);
+    return;
+  }
+
+  op->state->client_done_sent = GNUNET_YES;
+
+  GNUNET_STATISTICS_update (_GSS_statistics,
+                            "# Union operations succeeded",
+                            1,
+                            GNUNET_NO);
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "Signalling client that union operation is done\n");
+  ev = GNUNET_MQ_msg (rm,
+                      GNUNET_MESSAGE_TYPE_SET_RESULT);
+  rm->request_id = htonl (op->client_request_id);
+  rm->result_status = htons (GNUNET_SET_STATUS_DONE);
+  rm->element_type = htons (0);
+  rm->current_size = GNUNET_htonll (GNUNET_CONTAINER_multihashmap32_size (
+                                      op->state->key_to_element));
+  GNUNET_MQ_send (op->set->cs->mq,
+                  ev);
+}
+
+
+/**
+ * Tests if the operation is finished, and if so notify.
+ *
+ * @param op operation to check
+ */
+static void
+maybe_finish (struct Operation *op)
+{
+  unsigned int num_demanded;
+
+  num_demanded = GNUNET_CONTAINER_multihashmap_size (
+    op->state->demanded_hashes);
+
+  if (PHASE_FINISH_WAITING == op->state->phase)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "In PHASE_FINISH_WAITING, pending %u demands\n",
+         num_demanded);
+    if (0 == num_demanded)
+    {
+      struct GNUNET_MQ_Envelope *ev;
+
+      op->state->phase = PHASE_DONE;
+      ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DONE);
+      GNUNET_MQ_send (op->mq,
+                      ev);
+      /* We now wait until the other peer sends P2P_OVER
+       * after it got all elements from us. */
+    }
+  }
+  if (PHASE_FINISH_CLOSING == op->state->phase)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "In PHASE_FINISH_CLOSING, pending %u demands\n",
+         num_demanded);
+    if (0 == num_demanded)
+    {
+      op->state->phase = PHASE_DONE;
+      send_client_done (op);
+      _GSS_operation_destroy2 (op);
+    }
+  }
+}
+
+
+/**
+ * Check an element message from a remote peer.
+ *
+ * @param cls the union operation
+ * @param emsg the message
+ */
+int
+check_union_p2p_elements (void *cls,
+                          const struct GNUNET_SET_ElementMessage *emsg)
+{
+  struct Operation *op = cls;
+
+  if (GNUNET_SET_OPERATION_UNION != op->set->operation)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  if (0 == GNUNET_CONTAINER_multihashmap_size (op->state->demanded_hashes))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle an element message from a remote peer.
+ * Sent by the other peer either because we decoded an IBF and placed a demand,
+ * or because the other peer switched to full set transmission.
+ *
+ * @param cls the union operation
+ * @param emsg the message
+ */
+void
+handle_union_p2p_elements (void *cls,
+                           const struct GNUNET_SET_ElementMessage *emsg)
+{
+  struct Operation *op = cls;
+  struct ElementEntry *ee;
+  struct KeyEntry *ke;
+  uint16_t element_size;
+
+  element_size = ntohs (emsg->header.size) - sizeof(struct
+                                                    GNUNET_SET_ElementMessage);
+  ee = GNUNET_malloc (sizeof(struct ElementEntry) + element_size);
+  GNUNET_memcpy (&ee[1],
+                 &emsg[1],
+                 element_size);
+  ee->element.size = element_size;
+  ee->element.data = &ee[1];
+  ee->element.element_type = ntohs (emsg->element_type);
+  ee->remote = GNUNET_YES;
+  GNUNET_SET_element_hash (&ee->element,
+                           &ee->element_hash);
+  if (GNUNET_NO ==
+      GNUNET_CONTAINER_multihashmap_remove (op->state->demanded_hashes,
+                                            &ee->element_hash,
+                                            NULL))
+  {
+    /* We got something we didn't demand, since it's not in our map. */
+    GNUNET_break_op (0);
+    fail_union_operation (op);
+    return;
+  }
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Got element (size %u, hash %s) from peer\n",
+       (unsigned int) element_size,
+       GNUNET_h2s (&ee->element_hash));
+
+  GNUNET_STATISTICS_update (_GSS_statistics,
+                            "# received elements",
+                            1,
+                            GNUNET_NO);
+  GNUNET_STATISTICS_update (_GSS_statistics,
+                            "# exchanged elements",
+                            1,
+                            GNUNET_NO);
+
+  op->state->received_total++;
+
+  ke = op_get_element (op, &ee->element_hash);
+  if (NULL != ke)
+  {
+    /* Got repeated element.  Should not happen since
+     * we track demands. */
+    GNUNET_STATISTICS_update (_GSS_statistics,
+                              "# repeated elements",
+                              1,
+                              GNUNET_NO);
+    ke->received = GNUNET_YES;
+    GNUNET_free (ee);
+  }
+  else
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Registering new element from remote peer\n");
+    op->state->received_fresh++;
+    op_register_element (op, ee, GNUNET_YES);
+    /* only send results immediately if the client wants it */
+    switch (op->result_mode)
+    {
+    case GNUNET_SET_RESULT_ADDED:
+      send_client_element (op, &ee->element, GNUNET_SET_STATUS_OK);
+      break;
+
+    case GNUNET_SET_RESULT_SYMMETRIC:
+      send_client_element (op, &ee->element, GNUNET_SET_STATUS_ADD_LOCAL);
+      break;
+
+    default:
+      /* Result mode not supported, should have been caught earlier. */
+      GNUNET_break (0);
+      break;
+    }
+  }
+
+  if ((op->state->received_total > 8) &&
+      (op->state->received_fresh < op->state->received_total / 3))
+  {
+    /* The other peer gave us lots of old elements, there's something wrong. */
+    GNUNET_break_op (0);
+    fail_union_operation (op);
+    return;
+  }
+  GNUNET_CADET_receive_done (op->channel);
+  maybe_finish (op);
+}
+
+
+/**
+ * Check a full element message from a remote peer.
+ *
+ * @param cls the union operation
+ * @param emsg the message
+ */
+int
+check_union_p2p_full_element (void *cls,
+                              const struct GNUNET_SET_ElementMessage *emsg)
+{
+  struct Operation *op = cls;
+
+  if (GNUNET_SET_OPERATION_UNION != op->set->operation)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  // FIXME: check that we expect full elements here?
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle an element message from a remote peer.
+ *
+ * @param cls the union operation
+ * @param emsg the message
+ */
+void
+handle_union_p2p_full_element (void *cls,
+                               const struct GNUNET_SET_ElementMessage *emsg)
+{
+  struct Operation *op = cls;
+  struct ElementEntry *ee;
+  struct KeyEntry *ke;
+  uint16_t element_size;
+
+  element_size = ntohs (emsg->header.size) - sizeof(struct
+                                                    GNUNET_SET_ElementMessage);
+  ee = GNUNET_malloc (sizeof(struct ElementEntry) + element_size);
+  GNUNET_memcpy (&ee[1], &emsg[1], element_size);
+  ee->element.size = element_size;
+  ee->element.data = &ee[1];
+  ee->element.element_type = ntohs (emsg->element_type);
+  ee->remote = GNUNET_YES;
+  GNUNET_SET_element_hash (&ee->element, &ee->element_hash);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Got element (full diff, size %u, hash %s) from peer\n",
+       (unsigned int) element_size,
+       GNUNET_h2s (&ee->element_hash));
+
+  GNUNET_STATISTICS_update (_GSS_statistics,
+                            "# received elements",
+                            1,
+                            GNUNET_NO);
+  GNUNET_STATISTICS_update (_GSS_statistics,
+                            "# exchanged elements",
+                            1,
+                            GNUNET_NO);
+
+  op->state->received_total++;
+
+  ke = op_get_element (op, &ee->element_hash);
+  if (NULL != ke)
+  {
+    /* Got repeated element.  Should not happen since
+     * we track demands. */
+    GNUNET_STATISTICS_update (_GSS_statistics,
+                              "# repeated elements",
+                              1,
+                              GNUNET_NO);
+    ke->received = GNUNET_YES;
+    GNUNET_free (ee);
+  }
+  else
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Registering new element from remote peer\n");
+    op->state->received_fresh++;
+    op_register_element (op, ee, GNUNET_YES);
+    /* only send results immediately if the client wants it */
+    switch (op->result_mode)
+    {
+    case GNUNET_SET_RESULT_ADDED:
+      send_client_element (op, &ee->element, GNUNET_SET_STATUS_OK);
+      break;
+
+    case GNUNET_SET_RESULT_SYMMETRIC:
+      send_client_element (op, &ee->element, GNUNET_SET_STATUS_ADD_LOCAL);
+      break;
+
+    default:
+      /* Result mode not supported, should have been caught earlier. */
+      GNUNET_break (0);
+      break;
+    }
+  }
+
+  if ((GNUNET_YES == op->byzantine) &&
+      (op->state->received_total > 384 + op->state->received_fresh * 4) &&
+      (op->state->received_fresh < op->state->received_total / 6))
+  {
+    /* The other peer gave us lots of old elements, there's something wrong. */
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Other peer sent only %llu/%llu fresh elements, failing operation\n",
+         (unsigned long long) op->state->received_fresh,
+         (unsigned long long) op->state->received_total);
+    GNUNET_break_op (0);
+    fail_union_operation (op);
+    return;
+  }
+  GNUNET_CADET_receive_done (op->channel);
+}
+
+
+/**
+ * Send offers (for GNUNET_Hash-es) in response
+ * to inquiries (for IBF_Key-s).
+ *
+ * @param cls the union operation
+ * @param msg the message
+ */
+int
+check_union_p2p_inquiry (void *cls,
+                         const struct InquiryMessage *msg)
+{
+  struct Operation *op = cls;
+  unsigned int num_keys;
+
+  if (GNUNET_SET_OPERATION_UNION != op->set->operation)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  if (op->state->phase != PHASE_INVENTORY_PASSIVE)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  num_keys = (ntohs (msg->header.size) - sizeof(struct InquiryMessage))
+             / sizeof(struct IBF_Key);
+  if ((ntohs (msg->header.size) - sizeof(struct InquiryMessage))
+      != num_keys * sizeof(struct IBF_Key))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Send offers (for GNUNET_Hash-es) in response
+ * to inquiries (for IBF_Key-s).
+ *
+ * @param cls the union operation
+ * @param msg the message
+ */
+void
+handle_union_p2p_inquiry (void *cls,
+                          const struct InquiryMessage *msg)
+{
+  struct Operation *op = cls;
+  const struct IBF_Key *ibf_key;
+  unsigned int num_keys;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received union inquiry\n");
+  num_keys = (ntohs (msg->header.size) - sizeof(struct InquiryMessage))
+             / sizeof(struct IBF_Key);
+  ibf_key = (const struct IBF_Key *) &msg[1];
+  while (0 != num_keys--)
+  {
+    struct IBF_Key unsalted_key;
+
+    unsalt_key (ibf_key,
+                ntohl (msg->salt),
+                &unsalted_key);
+    send_offers_for_key (op,
+                         unsalted_key);
+    ibf_key++;
+  }
+  GNUNET_CADET_receive_done (op->channel);
+}
+
+
+/**
+ * Iterator over hash map entries, called to
+ * destroy the linked list of colliding ibf key entries.
+ *
+ * @param cls closure
+ * @param key current key code
+ * @param value value in the hash map
+ * @return #GNUNET_YES if we should continue to iterate,
+ *         #GNUNET_NO if not.
+ */
+static int
+send_missing_full_elements_iter (void *cls,
+                                 uint32_t key,
+                                 void *value)
+{
+  struct Operation *op = cls;
+  struct KeyEntry *ke = value;
+  struct GNUNET_MQ_Envelope *ev;
+  struct GNUNET_SET_ElementMessage *emsg;
+  struct ElementEntry *ee = ke->element;
+
+  if (GNUNET_YES == ke->received)
+    return GNUNET_YES;
+  ev = GNUNET_MQ_msg_extra (emsg,
+                            ee->element.size,
+                            GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_ELEMENT);
+  GNUNET_memcpy (&emsg[1],
+                 ee->element.data,
+                 ee->element.size);
+  emsg->element_type = htons (ee->element.element_type);
+  GNUNET_MQ_send (op->mq,
+                  ev);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Handle a request for full set transmission.
+ *
+ * @param cls closure, a set union operation
+ * @param mh the demand message
+ */
+void
+handle_union_p2p_request_full (void *cls,
+                               const struct GNUNET_MessageHeader *mh)
+{
+  struct Operation *op = cls;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received request for full set transmission\n");
+  if (GNUNET_SET_OPERATION_UNION != op->set->operation)
+  {
+    GNUNET_break_op (0);
+    fail_union_operation (op);
+    return;
+  }
+  if (PHASE_EXPECT_IBF != op->state->phase)
+  {
+    GNUNET_break_op (0);
+    fail_union_operation (op);
+    return;
+  }
+
+  // FIXME: we need to check that our set is larger than the
+  // byzantine_lower_bound by some threshold
+  send_full_set (op);
+  GNUNET_CADET_receive_done (op->channel);
+}
+
+
+/**
+ * Handle a "full done" message.
+ *
+ * @param cls closure, a set union operation
+ * @param mh the demand message
+ */
+void
+handle_union_p2p_full_done (void *cls,
+                            const struct GNUNET_MessageHeader *mh)
+{
+  struct Operation *op = cls;
+
+  switch (op->state->phase)
+  {
+  case PHASE_EXPECT_IBF:
+    {
+      struct GNUNET_MQ_Envelope *ev;
+
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "got FULL DONE, sending elements that other peer is missing\n");
+
+      /* send all the elements that did not come from the remote peer */
+      GNUNET_CONTAINER_multihashmap32_iterate (op->state->key_to_element,
+                                               &send_missing_full_elements_iter,
+                                               op);
+
+      ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_UNION_P2P_FULL_DONE);
+      GNUNET_MQ_send (op->mq,
+                      ev);
+      op->state->phase = PHASE_DONE;
+      /* we now wait until the other peer sends us the OVER message*/
+    }
+    break;
+
+  case PHASE_FULL_SENDING:
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "got FULL DONE, finishing\n");
+      /* We sent the full set, and got the response for that.  We're done. */
+      op->state->phase = PHASE_DONE;
+      GNUNET_CADET_receive_done (op->channel);
+      send_client_done (op);
+      _GSS_operation_destroy2 (op);
+      return;
+    }
+    break;
+
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Handle full done phase is %u\n",
+                (unsigned) op->state->phase);
+    GNUNET_break_op (0);
+    fail_union_operation (op);
+    return;
+  }
+  GNUNET_CADET_receive_done (op->channel);
+}
+
+
+/**
+ * Check a demand by the other peer for elements based on a list
+ * of `struct GNUNET_HashCode`s.
+ *
+ * @param cls closure, a set union operation
+ * @param mh the demand message
+ * @return #GNUNET_OK if @a mh is well-formed
+ */
+int
+check_union_p2p_demand (void *cls,
+                        const struct GNUNET_MessageHeader *mh)
+{
+  struct Operation *op = cls;
+  unsigned int num_hashes;
+
+  if (GNUNET_SET_OPERATION_UNION != op->set->operation)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
+               / sizeof(struct GNUNET_HashCode);
+  if ((ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
+      != num_hashes * sizeof(struct GNUNET_HashCode))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle a demand by the other peer for elements based on a list
+ * of `struct GNUNET_HashCode`s.
+ *
+ * @param cls closure, a set union operation
+ * @param mh the demand message
+ */
+void
+handle_union_p2p_demand (void *cls,
+                         const struct GNUNET_MessageHeader *mh)
+{
+  struct Operation *op = cls;
+  struct ElementEntry *ee;
+  struct GNUNET_SET_ElementMessage *emsg;
+  const struct GNUNET_HashCode *hash;
+  unsigned int num_hashes;
+  struct GNUNET_MQ_Envelope *ev;
+
+  num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
+               / sizeof(struct GNUNET_HashCode);
+  for (hash = (const struct GNUNET_HashCode *) &mh[1];
+       num_hashes > 0;
+       hash++, num_hashes--)
+  {
+    ee = GNUNET_CONTAINER_multihashmap_get (op->set->content->elements,
+                                            hash);
+    if (NULL == ee)
+    {
+      /* Demand for non-existing element. */
+      GNUNET_break_op (0);
+      fail_union_operation (op);
+      return;
+    }
+    if (GNUNET_NO == _GSS_is_element_of_operation (ee, op))
+    {
+      /* Probably confused lazily copied sets. */
+      GNUNET_break_op (0);
+      fail_union_operation (op);
+      return;
+    }
+    ev = GNUNET_MQ_msg_extra (emsg, ee->element.size,
+                              GNUNET_MESSAGE_TYPE_SET_P2P_ELEMENTS);
+    GNUNET_memcpy (&emsg[1], ee->element.data, ee->element.size);
+    emsg->reserved = htons (0);
+    emsg->element_type = htons (ee->element.element_type);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "[OP %p] Sending demanded element (size %u, hash %s) to peer\n",
+         op,
+         (unsigned int) ee->element.size,
+         GNUNET_h2s (&ee->element_hash));
+    GNUNET_MQ_send (op->mq, ev);
+    GNUNET_STATISTICS_update (_GSS_statistics,
+                              "# exchanged elements",
+                              1,
+                              GNUNET_NO);
+
+    switch (op->result_mode)
+    {
+    case GNUNET_SET_RESULT_ADDED:
+      /* Nothing to do. */
+      break;
+
+    case GNUNET_SET_RESULT_SYMMETRIC:
+      send_client_element (op, &ee->element, GNUNET_SET_STATUS_ADD_REMOTE);
+      break;
+
+    default:
+      /* Result mode not supported, should have been caught earlier. */
+      GNUNET_break (0);
+      break;
+    }
+  }
+  GNUNET_CADET_receive_done (op->channel);
+}
+
+
+/**
+ * Check offer (of `struct GNUNET_HashCode`s).
+ *
+ * @param cls the union operation
+ * @param mh the message
+ * @return #GNUNET_OK if @a mh is well-formed
+ */
+int
+check_union_p2p_offer (void *cls,
+                       const struct GNUNET_MessageHeader *mh)
+{
+  struct Operation *op = cls;
+  unsigned int num_hashes;
+
+  if (GNUNET_SET_OPERATION_UNION != op->set->operation)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  /* look up elements and send them */
+  if ((op->state->phase != PHASE_INVENTORY_PASSIVE) &&
+      (op->state->phase != PHASE_INVENTORY_ACTIVE))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
+               / sizeof(struct GNUNET_HashCode);
+  if ((ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader)) !=
+      num_hashes * sizeof(struct GNUNET_HashCode))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle offers (of `struct GNUNET_HashCode`s) and
+ * respond with demands (of `struct GNUNET_HashCode`s).
+ *
+ * @param cls the union operation
+ * @param mh the message
+ */
+void
+handle_union_p2p_offer (void *cls,
+                        const struct GNUNET_MessageHeader *mh)
+{
+  struct Operation *op = cls;
+  const struct GNUNET_HashCode *hash;
+  unsigned int num_hashes;
+
+  num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
+               / sizeof(struct GNUNET_HashCode);
+  for (hash = (const struct GNUNET_HashCode *) &mh[1];
+       num_hashes > 0;
+       hash++, num_hashes--)
+  {
+    struct ElementEntry *ee;
+    struct GNUNET_MessageHeader *demands;
+    struct GNUNET_MQ_Envelope *ev;
+
+    ee = GNUNET_CONTAINER_multihashmap_get (op->set->content->elements,
+                                            hash);
+    if (NULL != ee)
+      if (GNUNET_YES == _GSS_is_element_of_operation (ee, op))
+        continue;
+
+    if (GNUNET_YES ==
+        GNUNET_CONTAINER_multihashmap_contains (op->state->demanded_hashes,
+                                                hash))
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Skipped sending duplicate demand\n");
+      continue;
+    }
+
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multihashmap_put (
+                     op->state->demanded_hashes,
+                     hash,
+                     NULL,
+                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
+
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "[OP %p] Requesting element (hash %s)\n",
+         op, GNUNET_h2s (hash));
+    ev = GNUNET_MQ_msg_header_extra (demands,
+                                     sizeof(struct GNUNET_HashCode),
+                                     GNUNET_MESSAGE_TYPE_SET_UNION_P2P_DEMAND);
+    GNUNET_memcpy (&demands[1],
+                   hash,
+                   sizeof(struct GNUNET_HashCode));
+    GNUNET_MQ_send (op->mq, ev);
+  }
+  GNUNET_CADET_receive_done (op->channel);
+}
+
+
+/**
+ * Handle a done message from a remote peer
+ *
+ * @param cls the union operation
+ * @param mh the message
+ */
+void
+handle_union_p2p_done (void *cls,
+                       const struct GNUNET_MessageHeader *mh)
+{
+  struct Operation *op = cls;
+
+  if (GNUNET_SET_OPERATION_UNION != op->set->operation)
+  {
+    GNUNET_break_op (0);
+    fail_union_operation (op);
+    return;
+  }
+  switch (op->state->phase)
+  {
+  case PHASE_INVENTORY_PASSIVE:
+    /* We got all requests, but still have to send our elements in response. */
+    op->state->phase = PHASE_FINISH_WAITING;
+
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "got DONE (as passive partner), waiting for our demands to be satisfied\n");
+    /* The active peer is done sending offers
+     * and inquiries.  This means that all
+     * our responses to that (demands and offers)
+     * must be in flight (queued or in mesh).
+     *
+     * We should notify the active peer once
+     * all our demands are satisfied, so that the active
+     * peer can quit if we gave it everything.
+     */GNUNET_CADET_receive_done (op->channel);
+    maybe_finish (op);
+    return;
+
+  case PHASE_INVENTORY_ACTIVE:
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "got DONE (as active partner), waiting to finish\n");
+    /* All demands of the other peer are satisfied,
+     * and we processed all offers, thus we know
+     * exactly what our demands must be.
+     *
+     * We'll close the channel
+     * to the other peer once our demands are met.
+     */op->state->phase = PHASE_FINISH_CLOSING;
+    GNUNET_CADET_receive_done (op->channel);
+    maybe_finish (op);
+    return;
+
+  default:
+    GNUNET_break_op (0);
+    fail_union_operation (op);
+    return;
+  }
+}
+
+
+void
+handle_union_p2p_over (void *cls,
+                       const struct GNUNET_MessageHeader *mh)
+{
+  send_client_done (cls);
+}
+
+
+/**
+ * Initiate operation to evaluate a set union with a remote peer.
+ *
+ * @param op operation to perform (to be initialized)
+ * @param opaque_context message to be transmitted to the listener
+ *        to convince it to accept, may be NULL
+ */
+static struct OperationState *
+union_evaluate (struct Operation *op,
+                const struct GNUNET_MessageHeader *opaque_context)
+{
+  struct OperationState *state;
+  struct GNUNET_MQ_Envelope *ev;
+  struct OperationRequestMessage *msg;
+
+  ev = GNUNET_MQ_msg_nested_mh (msg,
+                                GNUNET_MESSAGE_TYPE_SET_P2P_OPERATION_REQUEST,
+                                opaque_context);
+  if (NULL == ev)
+  {
+    /* the context message is too large */
+    GNUNET_break (0);
+    return NULL;
+  }
+  state = GNUNET_new (struct OperationState);
+  state->demanded_hashes = GNUNET_CONTAINER_multihashmap_create (32,
+                                                                 GNUNET_NO);
+  /* copy the current generation's strata estimator for this operation */
+  state->se = strata_estimator_dup (op->set->state->se);
+  /* we started the operation, thus we have to send the operation request */
+  state->phase = PHASE_EXPECT_SE;
+  state->salt_receive = state->salt_send = 42; // FIXME?????
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Initiating union operation evaluation\n");
+  GNUNET_STATISTICS_update (_GSS_statistics,
+                            "# of total union operations",
+                            1,
+                            GNUNET_NO);
+  GNUNET_STATISTICS_update (_GSS_statistics,
+                            "# of initiated union operations",
+                            1,
+                            GNUNET_NO);
+  msg->operation = htonl (GNUNET_SET_OPERATION_UNION);
+  GNUNET_MQ_send (op->mq,
+                  ev);
+
+  if (NULL != opaque_context)
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "sent op request with context message\n");
+  else
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "sent op request without context message\n");
+
+  op->state = state;
+  initialize_key_to_element (op);
+  state->initial_size = GNUNET_CONTAINER_multihashmap32_size (
+    state->key_to_element);
+  return state;
+}
+
+
+/**
+ * Accept an union operation request from a remote peer.
+ * Only initializes the private operation state.
+ *
+ * @param op operation that will be accepted as a union operation
+ */
+static struct OperationState *
+union_accept (struct Operation *op)
+{
+  struct OperationState *state;
+  const struct StrataEstimator *se;
+  struct GNUNET_MQ_Envelope *ev;
+  struct StrataEstimatorMessage *strata_msg;
+  char *buf;
+  size_t len;
+  uint16_t type;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "accepting set union operation\n");
+  GNUNET_STATISTICS_update (_GSS_statistics,
+                            "# of accepted union operations",
+                            1,
+                            GNUNET_NO);
+  GNUNET_STATISTICS_update (_GSS_statistics,
+                            "# of total union operations",
+                            1,
+                            GNUNET_NO);
+
+  state = GNUNET_new (struct OperationState);
+  state->se = strata_estimator_dup (op->set->state->se);
+  state->demanded_hashes = GNUNET_CONTAINER_multihashmap_create (32,
+                                                                 GNUNET_NO);
+  state->salt_receive = state->salt_send = 42; // FIXME?????
+  op->state = state;
+  initialize_key_to_element (op);
+  state->initial_size = GNUNET_CONTAINER_multihashmap32_size (
+    state->key_to_element);
+
+  /* kick off the operation */
+  se = state->se;
+  buf = GNUNET_malloc (se->strata_count * IBF_BUCKET_SIZE * se->ibf_size);
+  len = strata_estimator_write (se,
+                                buf);
+  if (len < se->strata_count * IBF_BUCKET_SIZE * se->ibf_size)
+    type = GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SEC;
+  else
+    type = GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE;
+  ev = GNUNET_MQ_msg_extra (strata_msg,
+                            len,
+                            type);
+  GNUNET_memcpy (&strata_msg[1],
+                 buf,
+                 len);
+  GNUNET_free (buf);
+  strata_msg->set_size
+    = GNUNET_htonll (GNUNET_CONTAINER_multihashmap_size (
+                       op->set->content->elements));
+  GNUNET_MQ_send (op->mq,
+                  ev);
+  state->phase = PHASE_EXPECT_IBF;
+  return state;
+}
+
+
+/**
+ * Create a new set supporting the union operation
+ *
+ * We maintain one strata estimator per set and then manipulate it over the
+ * lifetime of the set, as recreating a strata estimator would be expensive.
+ *
+ * @return the newly created set, NULL on error
+ */
+static struct SetState *
+union_set_create (void)
+{
+  struct SetState *set_state;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "union set created\n");
+  set_state = GNUNET_new (struct SetState);
+  set_state->se = strata_estimator_create (SE_STRATA_COUNT,
+                                           SE_IBF_SIZE, SE_IBF_HASH_NUM);
+  if (NULL == set_state->se)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to allocate strata estimator\n");
+    GNUNET_free (set_state);
+    return NULL;
+  }
+  return set_state;
+}
+
+
+/**
+ * Add the element from the given element message to the set.
+ *
+ * @param set_state state of the set want to add to
+ * @param ee the element to add to the set
+ */
+static void
+union_add (struct SetState *set_state,
+           struct ElementEntry *ee)
+{
+  strata_estimator_insert (set_state->se,
+                           get_ibf_key (&ee->element_hash));
+}
+
+
+/**
+ * Remove the element given in the element message from the set.
+ * Only marks the element as removed, so that older set operations can still exchange it.
+ *
+ * @param set_state state of the set to remove from
+ * @param ee set element to remove
+ */
+static void
+union_remove (struct SetState *set_state,
+              struct ElementEntry *ee)
+{
+  strata_estimator_remove (set_state->se,
+                           get_ibf_key (&ee->element_hash));
+}
+
+
+/**
+ * Destroy a set that supports the union operation.
+ *
+ * @param set_state the set to destroy
+ */
+static void
+union_set_destroy (struct SetState *set_state)
+{
+  if (NULL != set_state->se)
+  {
+    strata_estimator_destroy (set_state->se);
+    set_state->se = NULL;
+  }
+  GNUNET_free (set_state);
+}
+
+
+/**
+ * Copy union-specific set state.
+ *
+ * @param state source state for copying the union state
+ * @return a copy of the union-specific set state
+ */
+static struct SetState *
+union_copy_state (struct SetState *state)
+{
+  struct SetState *new_state;
+
+  GNUNET_assert ((NULL != state) &&
+                 (NULL != state->se));
+  new_state = GNUNET_new (struct SetState);
+  new_state->se = strata_estimator_dup (state->se);
+
+  return new_state;
+}
+
+
+/**
+ * Handle case where channel went down for an operation.
+ *
+ * @param op operation that lost the channel
+ */
+static void
+union_channel_death (struct Operation *op)
+{
+  send_client_done (op);
+  _GSS_operation_destroy (op,
+                          GNUNET_YES);
+}
+
+
+/**
+ * Get the table with implementing functions for
+ * set union.
+ *
+ * @return the operation specific VTable
+ */
+const struct SetVT *
+_GSS_union_vt ()
+{
+  static const struct SetVT union_vt = {
+    .create = &union_set_create,
+    .add = &union_add,
+    .remove = &union_remove,
+    .destroy_set = &union_set_destroy,
+    .evaluate = &union_evaluate,
+    .accept = &union_accept,
+    .cancel = &union_op_cancel,
+    .copy_state = &union_copy_state,
+    .channel_death = &union_channel_death
+  };
+
+  return &union_vt;
+}
diff --git a/src/contrib/service/set/gnunet-service-set_union.h b/src/contrib/service/set/gnunet-service-set_union.h
new file mode 100644
index 000000000..68301c96b
--- /dev/null
+++ b/src/contrib/service/set/gnunet-service-set_union.h
@@ -0,0 +1,246 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2013-2017 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file set/gnunet-service-set_union.h
+ * @brief two-peer set operations
+ * @author Florian Dold
+ * @author Christian Grothoff
+ */
+#ifndef GNUNET_SERVICE_SET_UNION_H
+#define GNUNET_SERVICE_SET_UNION_H
+
+#include "gnunet-service-set.h"
+#include "gnunet-service-set_protocol.h"
+
+
+/**
+ * Handle a strata estimator from a remote peer
+ *
+ * @param cls the union operation
+ * @param msg the message
+ */
+int
+check_union_p2p_strata_estimator (void *cls,
+                                  const struct StrataEstimatorMessage *msg);
+
+
+/**
+ * Handle a strata estimator from a remote peer
+ *
+ * @param cls the union operation
+ * @param msg the message
+ */
+void
+handle_union_p2p_strata_estimator (void *cls,
+                                   const struct StrataEstimatorMessage *msg);
+
+
+/**
+ * Check an IBF message from a remote peer.
+ *
+ * Reassemble the IBF from multiple pieces, and
+ * process the whole IBF once possible.
+ *
+ * @param cls the union operation
+ * @param msg the header of the message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+int
+check_union_p2p_ibf (void *cls,
+                     const struct IBFMessage *msg);
+
+
+/**
+ * Handle an IBF message from a remote peer.
+ *
+ * Reassemble the IBF from multiple pieces, and
+ * process the whole IBF once possible.
+ *
+ * @param cls the union operation
+ * @param msg the header of the message
+ */
+void
+handle_union_p2p_ibf (void *cls,
+                      const struct IBFMessage *msg);
+
+
+/**
+ * Check an element message from a remote peer.
+ *
+ * @param cls the union operation
+ * @param emsg the message
+ */
+int
+check_union_p2p_elements (void *cls,
+                          const struct GNUNET_SET_ElementMessage *emsg);
+
+
+/**
+ * Handle an element message from a remote peer.
+ * Sent by the other peer either because we decoded an IBF and placed a demand,
+ * or because the other peer switched to full set transmission.
+ *
+ * @param cls the union operation
+ * @param emsg the message
+ */
+void
+handle_union_p2p_elements (void *cls,
+                           const struct GNUNET_SET_ElementMessage *emsg);
+
+
+/**
+ * Check a full element message from a remote peer.
+ *
+ * @param cls the union operation
+ * @param emsg the message
+ */
+int
+check_union_p2p_full_element (void *cls,
+                              const struct GNUNET_SET_ElementMessage *emsg);
+
+
+/**
+ * Handle an element message from a remote peer.
+ *
+ * @param cls the union operation
+ * @param emsg the message
+ */
+void
+handle_union_p2p_full_element (void *cls,
+                               const struct GNUNET_SET_ElementMessage *emsg);
+
+
+/**
+ * Send offers (for GNUNET_Hash-es) in response
+ * to inquiries (for IBF_Key-s).
+ *
+ * @param cls the union operation
+ * @param msg the message
+ */
+int
+check_union_p2p_inquiry (void *cls,
+                         const struct InquiryMessage *msg);
+
+
+/**
+ * Send offers (for GNUNET_Hash-es) in response
+ * to inquiries (for IBF_Key-s).
+ *
+ * @param cls the union operation
+ * @param msg the message
+ */
+void
+handle_union_p2p_inquiry (void *cls,
+                          const struct InquiryMessage *msg);
+
+
+/**
+ * Handle a request for full set transmission.
+ *
+ * @param cls closure, a set union operation
+ * @param mh the demand message
+ */
+void
+handle_union_p2p_request_full (void *cls,
+                               const struct GNUNET_MessageHeader *mh);
+
+
+/**
+ * Handle a "full done" message.
+ *
+ * @param cls closure, a set union operation
+ * @param mh the demand message
+ */
+void
+handle_union_p2p_full_done (void *cls,
+                            const struct GNUNET_MessageHeader *mh);
+
+
+/**
+ * Check a demand by the other peer for elements based on a list
+ * of `struct GNUNET_HashCode`s.
+ *
+ * @param cls closure, a set union operation
+ * @param mh the demand message
+ * @return #GNUNET_OK if @a mh is well-formed
+ */
+int
+check_union_p2p_demand (void *cls,
+                        const struct GNUNET_MessageHeader *mh);
+
+
+/**
+ * Handle a demand by the other peer for elements based on a list
+ * of `struct GNUNET_HashCode`s.
+ *
+ * @param cls closure, a set union operation
+ * @param mh the demand message
+ */
+void
+handle_union_p2p_demand (void *cls,
+                         const struct GNUNET_MessageHeader *mh);
+
+
+/**
+ * Check offer (of `struct GNUNET_HashCode`s).
+ *
+ * @param cls the union operation
+ * @param mh the message
+ * @return #GNUNET_OK if @a mh is well-formed
+ */
+int
+check_union_p2p_offer (void *cls,
+                       const struct GNUNET_MessageHeader *mh);
+
+
+/**
+ * Handle offers (of `struct GNUNET_HashCode`s) and
+ * respond with demands (of `struct GNUNET_HashCode`s).
+ *
+ * @param cls the union operation
+ * @param mh the message
+ */
+void
+handle_union_p2p_offer (void *cls,
+                        const struct GNUNET_MessageHeader *mh);
+
+
+/**
+ * Handle a done message from a remote peer
+ *
+ * @param cls the union operation
+ * @param mh the message
+ */
+void
+handle_union_p2p_done (void *cls,
+                       const struct GNUNET_MessageHeader *mh);
+
+/**
+ * Handle an over message from a remote peer
+ *
+ * @param cls the union operation
+ * @param mh the message
+ */
+void
+handle_union_p2p_over (void *cls,
+                       const struct GNUNET_MessageHeader *mh);
+
+
+#endif
diff --git a/src/contrib/service/set/gnunet-service-set_union_strata_estimator.c b/src/contrib/service/set/gnunet-service-set_union_strata_estimator.c
new file mode 100644
index 000000000..6de9fb5eb
--- /dev/null
+++ b/src/contrib/service/set/gnunet-service-set_union_strata_estimator.c
@@ -0,0 +1,297 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2012 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file set/gnunet-service-set_union_strata_estimator.c
+ * @brief invertible bloom filter
+ * @author Florian Dold
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "ibf.h"
+#include "gnunet-service-set_union_strata_estimator.h"
+
+
+/**
+ * Should we try compressing the strata estimator? This will
+ * break compatibility with the 0.10.1-network.
+ */
+#define FAIL_10_1_COMPATIBILTIY 1
+
+
+/**
+ * Write the given strata estimator to the buffer.
+ *
+ * @param se strata estimator to serialize
+ * @param[out] buf buffer to write to, must be of appropriate size
+ * @return number of bytes written to @a buf
+ */
+size_t
+strata_estimator_write (const struct StrataEstimator *se,
+                        void *buf)
+{
+  char *sbuf = buf;
+  unsigned int i;
+  size_t osize;
+
+  GNUNET_assert (NULL != se);
+  for (i = 0; i < se->strata_count; i++)
+  {
+    ibf_write_slice (se->strata[i],
+                     0,
+                     se->ibf_size,
+                     &sbuf[se->ibf_size * IBF_BUCKET_SIZE * i]);
+  }
+  osize = se->ibf_size * IBF_BUCKET_SIZE * se->strata_count;
+#if FAIL_10_1_COMPATIBILTIY
+  {
+    char *cbuf;
+    size_t nsize;
+
+    if (GNUNET_YES ==
+        GNUNET_try_compression (buf,
+                                osize,
+                                &cbuf,
+                                &nsize))
+    {
+      GNUNET_memcpy (buf, cbuf, nsize);
+      osize = nsize;
+      GNUNET_free (cbuf);
+    }
+  }
+#endif
+  return osize;
+}
+
+
+/**
+ * Read strata from the buffer into the given strata
+ * estimator.  The strata estimator must already be allocated.
+ *
+ * @param buf buffer to read from
+ * @param buf_len number of bytes in @a buf
+ * @param is_compressed is the data compressed?
+ * @param[out] se strata estimator to write to
+ * @return #GNUNET_OK on success
+ */
+int
+strata_estimator_read (const void *buf,
+                       size_t buf_len,
+                       int is_compressed,
+                       struct StrataEstimator *se)
+{
+  unsigned int i;
+  size_t osize;
+  char *dbuf;
+
+  dbuf = NULL;
+  if (GNUNET_YES == is_compressed)
+  {
+    osize = se->ibf_size * IBF_BUCKET_SIZE * se->strata_count;
+    dbuf = GNUNET_decompress (buf,
+                              buf_len,
+                              osize);
+    if (NULL == dbuf)
+    {
+      GNUNET_break_op (0);    /* bad compressed input data */
+      return GNUNET_SYSERR;
+    }
+    buf = dbuf;
+    buf_len = osize;
+  }
+
+  if (buf_len != se->strata_count * se->ibf_size * IBF_BUCKET_SIZE)
+  {
+    GNUNET_break (0);  /* very odd error */
+    GNUNET_free (dbuf);
+    return GNUNET_SYSERR;
+  }
+
+  for (i = 0; i < se->strata_count; i++)
+  {
+    ibf_read_slice (buf, 0, se->ibf_size, se->strata[i]);
+    buf += se->ibf_size * IBF_BUCKET_SIZE;
+  }
+  GNUNET_free (dbuf);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Add a key to the strata estimator.
+ *
+ * @param se strata estimator to add the key to
+ * @param key key to add
+ */
+void
+strata_estimator_insert (struct StrataEstimator *se,
+                         struct IBF_Key key)
+{
+  uint64_t v;
+  unsigned int i;
+
+  v = key.key_val;
+  /* count trailing '1'-bits of v */
+  for (i = 0; v & 1; v >>= 1, i++)
+    /* empty */;
+  ibf_insert (se->strata[i], key);
+}
+
+
+void
+strata_estimator_remove (struct StrataEstimator *se,
+                         struct IBF_Key key)
+{
+  uint64_t v;
+  unsigned int i;
+
+  v = key.key_val;
+  /* count trailing '1'-bits of v */
+  for (i = 0; v & 1; v >>= 1, i++)
+    /* empty */;
+  ibf_remove (se->strata[i], key);
+}
+
+
+/**
+ * Create a new strata estimator with the given parameters.
+ *
+ * @param strata_count number of stratas, that is, number of ibfs in the estimator
+ * @param ibf_size size of each ibf stratum
+ * @param ibf_hashnum hashnum parameter of each ibf
+ * @return a freshly allocated, empty strata estimator, NULL on error
+ */
+struct StrataEstimator *
+strata_estimator_create (unsigned int strata_count,
+                         uint32_t ibf_size,
+                         uint8_t ibf_hashnum)
+{
+  struct StrataEstimator *se;
+  unsigned int i;
+  unsigned int j;
+
+  se = GNUNET_new (struct StrataEstimator);
+  se->strata_count = strata_count;
+  se->ibf_size = ibf_size;
+  se->strata = GNUNET_new_array (strata_count,
+                                 struct InvertibleBloomFilter *);
+  for (i = 0; i < strata_count; i++)
+  {
+    se->strata[i] = ibf_create (ibf_size, ibf_hashnum);
+    if (NULL == se->strata[i])
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Failed to allocate memory for strata estimator\n");
+      for (j = 0; j < i; j++)
+        ibf_destroy (se->strata[i]);
+      GNUNET_free (se);
+      return NULL;
+    }
+  }
+  return se;
+}
+
+
+/**
+ * Estimate set difference with two strata estimators,
+ * i.e. arrays of IBFs.
+ * Does not not modify its arguments.
+ *
+ * @param se1 first strata estimator
+ * @param se2 second strata estimator
+ * @return the estimated difference
+ */
+unsigned int
+strata_estimator_difference (const struct StrataEstimator *se1,
+                             const struct StrataEstimator *se2)
+{
+  unsigned int count;
+
+  GNUNET_assert (se1->strata_count == se2->strata_count);
+  count = 0;
+  for (int i = se1->strata_count - 1; i >= 0; i--)
+  {
+    struct InvertibleBloomFilter *diff;
+    /* number of keys decoded from the ibf */
+
+    /* FIXME: implement this without always allocating new IBFs */
+    diff = ibf_dup (se1->strata[i]);
+    ibf_subtract (diff, se2->strata[i]);
+    for (int ibf_count = 0; GNUNET_YES; ibf_count++)
+    {
+      int more;
+
+      more = ibf_decode (diff, NULL, NULL);
+      if (GNUNET_NO == more)
+      {
+        count += ibf_count;
+        break;
+      }
+      /* Estimate if decoding fails or would not terminate */
+      if ((GNUNET_SYSERR == more) || (ibf_count > diff->size))
+      {
+        ibf_destroy (diff);
+        return count * (1 << (i + 1));
+      }
+    }
+    ibf_destroy (diff);
+  }
+  return count;
+}
+
+
+/**
+ * Make a copy of a strata estimator.
+ *
+ * @param se the strata estimator to copy
+ * @return the copy
+ */
+struct StrataEstimator *
+strata_estimator_dup (struct StrataEstimator *se)
+{
+  struct StrataEstimator *c;
+  unsigned int i;
+
+  c = GNUNET_new (struct StrataEstimator);
+  c->strata_count = se->strata_count;
+  c->ibf_size = se->ibf_size;
+  c->strata = GNUNET_new_array (se->strata_count,
+                                struct InvertibleBloomFilter *);
+  for (i = 0; i < se->strata_count; i++)
+    c->strata[i] = ibf_dup (se->strata[i]);
+  return c;
+}
+
+
+/**
+ * Destroy a strata estimator, free all of its resources.
+ *
+ * @param se strata estimator to destroy.
+ */
+void
+strata_estimator_destroy (struct StrataEstimator *se)
+{
+  unsigned int i;
+
+  for (i = 0; i < se->strata_count; i++)
+    ibf_destroy (se->strata[i]);
+  GNUNET_free (se->strata);
+  GNUNET_free (se);
+}
diff --git a/src/contrib/service/set/gnunet-service-set_union_strata_estimator.h b/src/contrib/service/set/gnunet-service-set_union_strata_estimator.h
new file mode 100644
index 000000000..94267a2dc
--- /dev/null
+++ b/src/contrib/service/set/gnunet-service-set_union_strata_estimator.h
@@ -0,0 +1,169 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2012 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file set/gnunet-service-set_union_strata_estimator.h
+ * @brief estimator of set difference
+ * @author Florian Dold
+ */
+
+#ifndef GNUNET_CONSENSUS_STRATA_ESTIMATOR_H
+#define GNUNET_CONSENSUS_STRATA_ESTIMATOR_H
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_util_lib.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+
+/**
+ * A handle to a strata estimator.
+ */
+struct StrataEstimator
+{
+  /**
+   * The IBFs of this strata estimator.
+   */
+  struct InvertibleBloomFilter **strata;
+
+  /**
+   * Size of the IBF array in @e strata
+   */
+  unsigned int strata_count;
+
+  /**
+   * Size of each IBF stratum (in bytes)
+   */
+  unsigned int ibf_size;
+};
+
+
+/**
+ * Write the given strata estimator to the buffer.
+ *
+ * @param se strata estimator to serialize
+ * @param[out] buf buffer to write to, must be of appropriate size
+ * @return number of bytes written to @a buf
+ */
+size_t
+strata_estimator_write (const struct StrataEstimator *se,
+                        void *buf);
+
+
+/**
+ * Read strata from the buffer into the given strata
+ * estimator.  The strata estimator must already be allocated.
+ *
+ * @param buf buffer to read from
+ * @param buf_len number of bytes in @a buf
+ * @param is_compressed is the data compressed?
+ * @param[out] se strata estimator to write to
+ * @return #GNUNET_OK on success
+ */
+int
+strata_estimator_read (const void *buf,
+                       size_t buf_len,
+                       int is_compressed,
+                       struct StrataEstimator *se);
+
+
+/**
+ * Create a new strata estimator with the given parameters.
+ *
+ * @param strata_count number of stratas, that is, number of ibfs in the estimator
+ * @param ibf_size size of each ibf stratum
+ * @param ibf_hashnum hashnum parameter of each ibf
+ * @return a freshly allocated, empty strata estimator, NULL on error
+ */
+struct StrataEstimator *
+strata_estimator_create (unsigned int strata_count,
+                         uint32_t ibf_size,
+                         uint8_t ibf_hashnum);
+
+
+/**
+ * Get an estimation of the symmetric difference of the elements
+ * contained in both strata estimators.
+ *
+ * @param se1 first strata estimator
+ * @param se2 second strata estimator
+ * @return abs(|se1| - |se2|)
+ */
+unsigned int
+strata_estimator_difference (const struct StrataEstimator *se1,
+                             const struct StrataEstimator *se2);
+
+
+/**
+ * Add a key to the strata estimator.
+ *
+ * @param se strata estimator to add the key to
+ * @param key key to add
+ */
+void
+strata_estimator_insert (struct StrataEstimator *se,
+                         struct IBF_Key key);
+
+
+/**
+ * Remove a key from the strata estimator.
+ *
+ * @param se strata estimator to remove the key from
+ * @param key key to remove
+ */
+void
+strata_estimator_remove (struct StrataEstimator *se,
+                         struct IBF_Key key);
+
+
+/**
+ * Destroy a strata estimator, free all of its resources.
+ *
+ * @param se strata estimator to destroy.
+ */
+void
+strata_estimator_destroy (struct StrataEstimator *se);
+
+
+/**
+ * Make a copy of a strata estimator.
+ *
+ * @param se the strata estimator to copy
+ * @return the copy
+ */
+struct StrataEstimator *
+strata_estimator_dup (struct StrataEstimator *se);
+
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/contrib/service/set/gnunet-set-ibf-profiler.c b/src/contrib/service/set/gnunet-set-ibf-profiler.c
new file mode 100644
index 000000000..6465b15b8
--- /dev/null
+++ b/src/contrib/service/set/gnunet-set-ibf-profiler.c
@@ -0,0 +1,308 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2012 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file set/gnunet-set-ibf-profiler.c
+ * @brief tool for profiling the invertible bloom filter implementation
+ * @author Florian Dold
+ */
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+
+#include "ibf.h"
+
+static unsigned int asize = 10;
+static unsigned int bsize = 10;
+static unsigned int csize = 10;
+static unsigned int hash_num = 4;
+static unsigned int ibf_size = 80;
+
+/* FIXME: add parameter for this */
+static enum GNUNET_CRYPTO_Quality random_quality = GNUNET_CRYPTO_QUALITY_WEAK;
+
+static struct GNUNET_CONTAINER_MultiHashMap *set_a;
+static struct GNUNET_CONTAINER_MultiHashMap *set_b;
+/* common elements in a and b */
+static struct GNUNET_CONTAINER_MultiHashMap *set_c;
+
+static struct GNUNET_CONTAINER_MultiHashMap *key_to_hashcode;
+
+static struct InvertibleBloomFilter *ibf_a;
+static struct InvertibleBloomFilter *ibf_b;
+
+
+static void
+register_hashcode (struct GNUNET_HashCode *hash)
+{
+  struct GNUNET_HashCode replicated;
+  struct IBF_Key key;
+
+  key = ibf_key_from_hashcode (hash);
+  ibf_hashcode_from_key (key, &replicated);
+  (void) GNUNET_CONTAINER_multihashmap_put (
+    key_to_hashcode,
+    &replicated,
+    GNUNET_memdup (hash, sizeof *hash),
+    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+}
+
+
+static void
+iter_hashcodes (struct IBF_Key key,
+                GNUNET_CONTAINER_MultiHashMapIteratorCallback iter,
+                void *cls)
+{
+  struct GNUNET_HashCode replicated;
+
+  ibf_hashcode_from_key (key, &replicated);
+  GNUNET_CONTAINER_multihashmap_get_multiple (key_to_hashcode,
+                                              &replicated,
+                                              iter,
+                                              cls);
+}
+
+
+static int
+insert_iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct InvertibleBloomFilter *ibf = cls;
+
+  ibf_insert (ibf, ibf_key_from_hashcode (key));
+  return GNUNET_YES;
+}
+
+
+static int
+remove_iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct GNUNET_CONTAINER_MultiHashMap *hashmap = cls;
+
+  /* if remove fails, there just was a collision with another key */
+  (void) GNUNET_CONTAINER_multihashmap_remove (hashmap, value, NULL);
+  return GNUNET_YES;
+}
+
+
+static void
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_HashCode id;
+  struct IBF_Key ibf_key;
+  int i;
+  int side;
+  int res;
+  struct GNUNET_TIME_Absolute start_time;
+  struct GNUNET_TIME_Relative delta_time;
+
+  set_a =
+    GNUNET_CONTAINER_multihashmap_create (((asize == 0) ? 1 : (asize + csize)),
+                                          GNUNET_NO);
+  set_b =
+    GNUNET_CONTAINER_multihashmap_create (((bsize == 0) ? 1 : (bsize + csize)),
+                                          GNUNET_NO);
+  set_c = GNUNET_CONTAINER_multihashmap_create (((csize == 0) ? 1 : csize),
+                                                GNUNET_NO);
+
+  key_to_hashcode =
+    GNUNET_CONTAINER_multihashmap_create (((asize + bsize + csize == 0)
+                                           ? 1
+                                           : (asize + bsize + csize)),
+                                          GNUNET_NO);
+
+  printf ("hash-num=%u, size=%u, #(A-B)=%u, #(B-A)=%u, #(A&B)=%u\n",
+          hash_num,
+          ibf_size,
+          asize,
+          bsize,
+          csize);
+
+  i = 0;
+  while (i < asize)
+  {
+    GNUNET_CRYPTO_hash_create_random (random_quality, &id);
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id))
+      continue;
+    GNUNET_break (GNUNET_OK ==
+                  GNUNET_CONTAINER_multihashmap_put (
+                    set_a,
+                    &id,
+                    NULL,
+                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+    register_hashcode (&id);
+    i++;
+  }
+  i = 0;
+  while (i < bsize)
+  {
+    GNUNET_CRYPTO_hash_create_random (random_quality, &id);
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id))
+      continue;
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_b, &id))
+      continue;
+    GNUNET_break (GNUNET_OK ==
+                  GNUNET_CONTAINER_multihashmap_put (
+                    set_b,
+                    &id,
+                    NULL,
+                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+    register_hashcode (&id);
+    i++;
+  }
+  i = 0;
+  while (i < csize)
+  {
+    GNUNET_CRYPTO_hash_create_random (random_quality, &id);
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_a, &id))
+      continue;
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_b, &id))
+      continue;
+    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (set_c, &id))
+      continue;
+    GNUNET_break (GNUNET_OK ==
+                  GNUNET_CONTAINER_multihashmap_put (
+                    set_c,
+                    &id,
+                    NULL,
+                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+    register_hashcode (&id);
+    i++;
+  }
+
+  ibf_a = ibf_create (ibf_size, hash_num);
+  ibf_b = ibf_create (ibf_size, hash_num);
+  if ((NULL == ibf_a) || (NULL == ibf_b))
+  {
+    /* insufficient memory */
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+
+  printf ("generated sets\n");
+
+  start_time = GNUNET_TIME_absolute_get ();
+
+  GNUNET_CONTAINER_multihashmap_iterate (set_a, &insert_iterator, ibf_a);
+  GNUNET_CONTAINER_multihashmap_iterate (set_b, &insert_iterator, ibf_b);
+  GNUNET_CONTAINER_multihashmap_iterate (set_c, &insert_iterator, ibf_a);
+  GNUNET_CONTAINER_multihashmap_iterate (set_c, &insert_iterator, ibf_b);
+
+  delta_time = GNUNET_TIME_absolute_get_duration (start_time);
+
+  printf ("encoded in: %s\n",
+          GNUNET_STRINGS_relative_time_to_string (delta_time, GNUNET_NO));
+
+  ibf_subtract (ibf_a, ibf_b);
+
+
+  start_time = GNUNET_TIME_absolute_get ();
+
+  for (i = 0; i <= asize + bsize; i++)
+  {
+    res = ibf_decode (ibf_a, &side, &ibf_key);
+    if (GNUNET_SYSERR == res)
+    {
+      printf ("decode failed, %u/%u elements left\n",
+              GNUNET_CONTAINER_multihashmap_size (set_a)
+              + GNUNET_CONTAINER_multihashmap_size (set_b),
+              asize + bsize);
+      return;
+    }
+    if (GNUNET_NO == res)
+    {
+      if ((0 == GNUNET_CONTAINER_multihashmap_size (set_b)) &&
+          (0 == GNUNET_CONTAINER_multihashmap_size (set_a)))
+      {
+        delta_time = GNUNET_TIME_absolute_get_duration (start_time);
+        printf ("decoded successfully in: %s\n",
+                GNUNET_STRINGS_relative_time_to_string (delta_time, GNUNET_NO));
+      }
+      else
+      {
+        printf ("decode missed elements (should never happen)\n");
+      }
+      return;
+    }
+
+    if (side == 1)
+      iter_hashcodes (ibf_key, remove_iterator, set_a);
+    if (side == -1)
+      iter_hashcodes (ibf_key, remove_iterator, set_b);
+  }
+  printf ("cyclic IBF, %u/%u elements left\n",
+          GNUNET_CONTAINER_multihashmap_size (set_a)
+          + GNUNET_CONTAINER_multihashmap_size (set_b),
+          asize + bsize);
+}
+
+
+int
+main (int argc, char **argv)
+{
+  struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_option_uint ('A',
+                               "asize",
+                               NULL,
+                               gettext_noop ("number of element in set A-B"),
+                               &asize),
+
+    GNUNET_GETOPT_option_uint ('B',
+                               "bsize",
+                               NULL,
+                               gettext_noop ("number of element in set B-A"),
+                               &bsize),
+
+    GNUNET_GETOPT_option_uint ('C',
+                               "csize",
+                               NULL,
+                               gettext_noop (
+                                 "number of common elements in A and B"),
+                               &csize),
+
+    GNUNET_GETOPT_option_uint ('k',
+                               "hash-num",
+                               NULL,
+                               gettext_noop ("hash num"),
+                               &hash_num),
+
+    GNUNET_GETOPT_option_uint ('s',
+                               "ibf-size",
+                               NULL,
+                               gettext_noop ("ibf size"),
+                               &ibf_size),
+
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  GNUNET_PROGRAM_run2 (argc,
+                       argv,
+                       "gnunet-consensus-ibf",
+                       "help",
+                       options,
+                       &run,
+                       NULL,
+                       GNUNET_YES);
+  return 0;
+}
diff --git a/src/contrib/service/set/ibf.c b/src/contrib/service/set/ibf.c
new file mode 100644
index 000000000..b6fb52b6b
--- /dev/null
+++ b/src/contrib/service/set/ibf.c
@@ -0,0 +1,410 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2012 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file set/ibf.c
+ * @brief implementation of the invertible bloom filter
+ * @author Florian Dold
+ */
+
+#include "platform.h"
+#include "ibf.h"
+
+/**
+ * Compute the key's hash from the key.
+ * Redefine to use a different hash function.
+ */
+#define IBF_KEY_HASH_VAL(k) (GNUNET_CRYPTO_crc32_n (&(k), sizeof(struct \
+                                                                 IBF_KeyHash)))
+
+/**
+ * Create a key from a hashcode.
+ *
+ * @param hash the hashcode
+ * @return a key
+ */
+struct IBF_Key
+ibf_key_from_hashcode (const struct GNUNET_HashCode *hash)
+{
+  return *(struct IBF_Key *) hash;
+}
+
+
+/**
+ * Create a hashcode from a key, by replicating the key
+ * until the hascode is filled
+ *
+ * @param key the key
+ * @param dst hashcode to store the result in
+ */
+void
+ibf_hashcode_from_key (struct IBF_Key key,
+                       struct GNUNET_HashCode *dst)
+{
+  struct IBF_Key *p;
+  unsigned int i;
+  const unsigned int keys_per_hashcode = sizeof(struct GNUNET_HashCode)
+                                         / sizeof(struct IBF_Key);
+
+  p = (struct IBF_Key *) dst;
+  for (i = 0; i < keys_per_hashcode; i++)
+    *p++ = key;
+}
+
+
+/**
+ * Create an invertible bloom filter.
+ *
+ * @param size number of IBF buckets
+ * @param hash_num number of buckets one element is hashed in
+ * @return the newly created invertible bloom filter, NULL on error
+ */
+struct InvertibleBloomFilter *
+ibf_create (uint32_t size, uint8_t hash_num)
+{
+  struct InvertibleBloomFilter *ibf;
+
+  GNUNET_assert (0 != size);
+
+  ibf = GNUNET_new (struct InvertibleBloomFilter);
+  ibf->count = GNUNET_malloc_large (size * sizeof(uint8_t));
+  if (NULL == ibf->count)
+  {
+    GNUNET_free (ibf);
+    return NULL;
+  }
+  ibf->key_sum = GNUNET_malloc_large (size * sizeof(struct IBF_Key));
+  if (NULL == ibf->key_sum)
+  {
+    GNUNET_free (ibf->count);
+    GNUNET_free (ibf);
+    return NULL;
+  }
+  ibf->key_hash_sum = GNUNET_malloc_large (size * sizeof(struct IBF_KeyHash));
+  if (NULL == ibf->key_hash_sum)
+  {
+    GNUNET_free (ibf->key_sum);
+    GNUNET_free (ibf->count);
+    GNUNET_free (ibf);
+    return NULL;
+  }
+  ibf->size = size;
+  ibf->hash_num = hash_num;
+
+  return ibf;
+}
+
+
+/**
+ * Store unique bucket indices for the specified key in dst.
+ */
+static void
+ibf_get_indices (const struct InvertibleBloomFilter *ibf,
+                 struct IBF_Key key,
+                 int *dst)
+{
+  uint32_t filled;
+  uint32_t i;
+  uint32_t bucket;
+
+  bucket = GNUNET_CRYPTO_crc32_n (&key, sizeof key);
+  for (i = 0, filled = 0; filled < ibf->hash_num; i++)
+  {
+    unsigned int j;
+    uint64_t x;
+    for (j = 0; j < filled; j++)
+      if (dst[j] == bucket)
+        goto try_next;
+    dst[filled++] = bucket % ibf->size;
+try_next:;
+    x = ((uint64_t) bucket << 32) | i;
+    bucket = GNUNET_CRYPTO_crc32_n (&x, sizeof x);
+  }
+}
+
+
+static void
+ibf_insert_into (struct InvertibleBloomFilter *ibf,
+                 struct IBF_Key key,
+                 const int *buckets, int side)
+{
+  int i;
+
+  for (i = 0; i < ibf->hash_num; i++)
+  {
+    const int bucket = buckets[i];
+    ibf->count[bucket].count_val += side;
+    ibf->key_sum[bucket].key_val ^= key.key_val;
+    ibf->key_hash_sum[bucket].key_hash_val
+      ^= IBF_KEY_HASH_VAL (key);
+  }
+}
+
+
+/**
+ * Insert a key into an IBF.
+ *
+ * @param ibf the IBF
+ * @param key the element's hash code
+ */
+void
+ibf_insert (struct InvertibleBloomFilter *ibf, struct IBF_Key key)
+{
+  int buckets[ibf->hash_num];
+
+  GNUNET_assert (ibf->hash_num <= ibf->size);
+  ibf_get_indices (ibf, key, buckets);
+  ibf_insert_into (ibf, key, buckets, 1);
+}
+
+
+/**
+ * Remove a key from an IBF.
+ *
+ * @param ibf the IBF
+ * @param key the element's hash code
+ */
+void
+ibf_remove (struct InvertibleBloomFilter *ibf, struct IBF_Key key)
+{
+  int buckets[ibf->hash_num];
+
+  GNUNET_assert (ibf->hash_num <= ibf->size);
+  ibf_get_indices (ibf, key, buckets);
+  ibf_insert_into (ibf, key, buckets, -1);
+}
+
+
+/**
+ * Test is the IBF is empty, i.e. all counts, keys and key hashes are zero.
+ */
+static int
+ibf_is_empty (struct InvertibleBloomFilter *ibf)
+{
+  int i;
+
+  for (i = 0; i < ibf->size; i++)
+  {
+    if (0 != ibf->count[i].count_val)
+      return GNUNET_NO;
+    if (0 != ibf->key_hash_sum[i].key_hash_val)
+      return GNUNET_NO;
+    if (0 != ibf->key_sum[i].key_val)
+      return GNUNET_NO;
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * Decode and remove an element from the IBF, if possible.
+ *
+ * @param ibf the invertible bloom filter to decode
+ * @param ret_side sign of the cell's count where the decoded element came from.
+ *                 A negative sign indicates that the element was recovered
+ *                 resides in an IBF that was previously subtracted from.
+ * @param ret_id receives the hash code of the decoded element, if successful
+ * @return GNUNET_YES if decoding an element was successful,
+ *         GNUNET_NO if the IBF is empty,
+ *         GNUNET_SYSERR if the decoding has failed
+ */
+int
+ibf_decode (struct InvertibleBloomFilter *ibf,
+            int *ret_side, struct IBF_Key *ret_id)
+{
+  struct IBF_KeyHash hash;
+  int i;
+  int buckets[ibf->hash_num];
+
+  GNUNET_assert (NULL != ibf);
+
+  for (i = 0; i < ibf->size; i++)
+  {
+    int j;
+    int hit;
+
+    /* we can only decode from pure buckets */
+    if ((1 != ibf->count[i].count_val) && (-1 != ibf->count[i].count_val))
+      continue;
+
+    hash.key_hash_val = IBF_KEY_HASH_VAL (ibf->key_sum[i]);
+
+    /* test if the hash matches the key */
+    if (hash.key_hash_val != ibf->key_hash_sum[i].key_hash_val)
+      continue;
+
+    /* test if key in bucket hits its own location,
+     * if not, the key hash was subject to collision */
+    hit = GNUNET_NO;
+    ibf_get_indices (ibf, ibf->key_sum[i], buckets);
+    for (j = 0; j < ibf->hash_num; j++)
+      if (buckets[j] == i)
+        hit = GNUNET_YES;
+
+    if (GNUNET_NO == hit)
+      continue;
+
+    if (NULL != ret_side)
+      *ret_side = ibf->count[i].count_val;
+    if (NULL != ret_id)
+      *ret_id = ibf->key_sum[i];
+
+    /* insert on the opposite side, effectively removing the element */
+    ibf_insert_into (ibf, ibf->key_sum[i], buckets, -ibf->count[i].count_val);
+
+    return GNUNET_YES;
+  }
+
+  if (GNUNET_YES == ibf_is_empty (ibf))
+    return GNUNET_NO;
+  return GNUNET_SYSERR;
+}
+
+
+/**
+ * Write buckets from an ibf to a buffer.
+ * Exactly (IBF_BUCKET_SIZE*ibf->size) bytes are written to buf.
+ *
+ * @param ibf the ibf to write
+ * @param start with which bucket to start
+ * @param count how many buckets to write
+ * @param buf buffer to write the data to
+ */
+void
+ibf_write_slice (const struct InvertibleBloomFilter *ibf, uint32_t start,
+                 uint32_t count, void *buf)
+{
+  struct IBF_Key *key_dst;
+  struct IBF_KeyHash *key_hash_dst;
+  struct IBF_Count *count_dst;
+
+    GNUNET_assert (start + count <= ibf->size);
+
+  /* copy keys */
+  key_dst = (struct IBF_Key *) buf;
+  GNUNET_memcpy (key_dst, ibf->key_sum + start, count * sizeof *key_dst);
+  key_dst += count;
+  /* copy key hashes */
+  key_hash_dst = (struct IBF_KeyHash *) key_dst;
+  GNUNET_memcpy (key_hash_dst, ibf->key_hash_sum + start, count
+                 * sizeof *key_hash_dst);
+  key_hash_dst += count;
+  /* copy counts */
+  count_dst = (struct IBF_Count *) key_hash_dst;
+  GNUNET_memcpy (count_dst, ibf->count + start, count * sizeof *count_dst);
+}
+
+
+/**
+ * Read buckets from a buffer into an ibf.
+ *
+ * @param buf pointer to the buffer to read from
+ * @param start which bucket to start at
+ * @param count how many buckets to read
+ * @param ibf the ibf to read from
+ */
+void
+ibf_read_slice (const void *buf, uint32_t start, uint32_t count, struct
+                InvertibleBloomFilter *ibf)
+{
+  struct IBF_Key *key_src;
+  struct IBF_KeyHash *key_hash_src;
+  struct IBF_Count *count_src;
+
+  GNUNET_assert (count > 0);
+  GNUNET_assert (start + count <= ibf->size);
+
+  /* copy keys */
+  key_src = (struct IBF_Key *) buf;
+  GNUNET_memcpy (ibf->key_sum + start, key_src, count * sizeof *key_src);
+  key_src += count;
+  /* copy key hashes */
+  key_hash_src = (struct IBF_KeyHash *) key_src;
+  GNUNET_memcpy (ibf->key_hash_sum + start, key_hash_src, count
+                 * sizeof *key_hash_src);
+  key_hash_src += count;
+  /* copy counts */
+  count_src = (struct IBF_Count *) key_hash_src;
+  GNUNET_memcpy (ibf->count + start, count_src, count * sizeof *count_src);
+}
+
+
+/**
+ * Subtract ibf2 from ibf1, storing the result in ibf1.
+ * The two IBF's must have the same parameters size and hash_num.
+ *
+ * @param ibf1 IBF that is subtracted from
+ * @param ibf2 IBF that will be subtracted from ibf1
+ */
+void
+ibf_subtract (struct InvertibleBloomFilter *ibf1, const struct
+              InvertibleBloomFilter *ibf2)
+{
+  int i;
+
+  GNUNET_assert (ibf1->size == ibf2->size);
+  GNUNET_assert (ibf1->hash_num == ibf2->hash_num);
+
+  for (i = 0; i < ibf1->size; i++)
+  {
+    ibf1->count[i].count_val -= ibf2->count[i].count_val;
+    ibf1->key_hash_sum[i].key_hash_val ^= ibf2->key_hash_sum[i].key_hash_val;
+    ibf1->key_sum[i].key_val ^= ibf2->key_sum[i].key_val;
+  }
+}
+
+
+/**
+ * Create a copy of an IBF, the copy has to be destroyed properly.
+ *
+ * @param ibf the IBF to copy
+ */
+struct InvertibleBloomFilter *
+ibf_dup (const struct InvertibleBloomFilter *ibf)
+{
+  struct InvertibleBloomFilter *copy;
+
+  copy = GNUNET_malloc (sizeof *copy);
+  copy->hash_num = ibf->hash_num;
+  copy->size = ibf->size;
+  copy->key_hash_sum = GNUNET_memdup (ibf->key_hash_sum, ibf->size
+                                      * sizeof(struct IBF_KeyHash));
+  copy->key_sum = GNUNET_memdup (ibf->key_sum, ibf->size * sizeof(struct
+                                                                  IBF_Key));
+  copy->count = GNUNET_memdup (ibf->count, ibf->size * sizeof(struct
+                                                              IBF_Count));
+  return copy;
+}
+
+
+/**
+ * Destroy all resources associated with the invertible bloom filter.
+ * No more ibf_*-functions may be called on ibf after calling destroy.
+ *
+ * @param ibf the intertible bloom filter to destroy
+ */
+void
+ibf_destroy (struct InvertibleBloomFilter *ibf)
+{
+  GNUNET_free (ibf->key_sum);
+  GNUNET_free (ibf->key_hash_sum);
+  GNUNET_free (ibf->count);
+  GNUNET_free (ibf);
+}
diff --git a/src/contrib/service/set/ibf.h b/src/contrib/service/set/ibf.h
new file mode 100644
index 000000000..334a797ef
--- /dev/null
+++ b/src/contrib/service/set/ibf.h
@@ -0,0 +1,256 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2012 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file set/ibf.h
+ * @brief invertible bloom filter
+ * @author Florian Dold
+ */
+
+#ifndef GNUNET_CONSENSUS_IBF_H
+#define GNUNET_CONSENSUS_IBF_H
+
+#include "platform.h"
+#include "gnunet_util_lib.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+
+/**
+ * Keys that can be inserted into and removed from an IBF.
+ */
+struct IBF_Key
+{
+  uint64_t key_val;
+};
+
+
+/**
+ * Hash of an IBF key.
+ */
+struct IBF_KeyHash
+{
+  uint32_t key_hash_val;
+};
+
+
+/**
+ * Type of the count field of IBF buckets.
+ */
+struct IBF_Count
+{
+  int8_t count_val;
+};
+
+
+/**
+ * Size of one ibf bucket in bytes
+ */
+#define IBF_BUCKET_SIZE (sizeof(struct IBF_Count) + sizeof(struct IBF_Key)   \
+                         + sizeof(struct IBF_KeyHash))
+
+
+/**
+ * Invertible bloom filter (IBF).
+ *
+ * An IBF is a counting bloom filter that has the ability to restore
+ * the hashes of its stored elements with high probability.
+ */
+struct InvertibleBloomFilter
+{
+  /**
+   * How many cells does this IBF have?
+   */
+  uint32_t size;
+
+  /**
+   * In how many cells do we hash one element?
+   * Usually 4 or 3.
+   */
+  uint8_t hash_num;
+
+  /**
+   * Xor sums of the elements' keys, used to identify the elements.
+   * Array of 'size' elements.
+   */
+  struct IBF_Key *key_sum;
+
+  /**
+   * Xor sums of the hashes of the keys of inserted elements.
+   * Array of 'size' elements.
+   */
+  struct IBF_KeyHash *key_hash_sum;
+
+  /**
+   * How many times has a bucket been hit?
+   * Can be negative, as a result of IBF subtraction.
+   * Array of 'size' elements.
+   */
+  struct IBF_Count *count;
+};
+
+
+/**
+ * Write buckets from an ibf to a buffer.
+ * Exactly (IBF_BUCKET_SIZE*ibf->size) bytes are written to buf.
+ *
+ * @param ibf the ibf to write
+ * @param start with which bucket to start
+ * @param count how many buckets to write
+ * @param buf buffer to write the data to
+ */
+void
+ibf_write_slice (const struct InvertibleBloomFilter *ibf,
+                 uint32_t start,
+                 uint32_t count,
+                 void *buf);
+
+
+/**
+ * Read buckets from a buffer into an ibf.
+ *
+ * @param buf pointer to the buffer to read from
+ * @param start which bucket to start at
+ * @param count how many buckets to read
+ * @param ibf the ibf to write to
+ */
+void
+ibf_read_slice (const void *buf,
+                uint32_t start,
+                uint32_t count,
+                struct InvertibleBloomFilter *ibf);
+
+
+/**
+ * Create a key from a hashcode.
+ *
+ * @param hash the hashcode
+ * @return a key
+ */
+struct IBF_Key
+ibf_key_from_hashcode (const struct GNUNET_HashCode *hash);
+
+
+/**
+ * Create a hashcode from a key, by replicating the key
+ * until the hascode is filled
+ *
+ * @param key the key
+ * @param dst hashcode to store the result in
+ */
+void
+ibf_hashcode_from_key (struct IBF_Key key, struct GNUNET_HashCode *dst);
+
+
+/**
+ * Create an invertible bloom filter.
+ *
+ * @param size number of IBF buckets
+ * @param hash_num number of buckets one element is hashed in, usually 3 or 4
+ * @return the newly created invertible bloom filter, NULL on error
+ */
+struct InvertibleBloomFilter *
+ibf_create (uint32_t size, uint8_t hash_num);
+
+
+/**
+ * Insert a key into an IBF.
+ *
+ * @param ibf the IBF
+ * @param key the element's hash code
+ */
+void
+ibf_insert (struct InvertibleBloomFilter *ibf, struct IBF_Key key);
+
+
+/**
+ * Remove a key from an IBF.
+ *
+ * @param ibf the IBF
+ * @param key the element's hash code
+ */
+void
+ibf_remove (struct InvertibleBloomFilter *ibf, struct IBF_Key key);
+
+
+/**
+ * Subtract ibf2 from ibf1, storing the result in ibf1.
+ * The two IBF's must have the same parameters size and hash_num.
+ *
+ * @param ibf1 IBF that is subtracted from
+ * @param ibf2 IBF that will be subtracted from ibf1
+ */
+void
+ibf_subtract (struct InvertibleBloomFilter *ibf1,
+              const struct InvertibleBloomFilter *ibf2);
+
+
+/**
+ * Decode and remove an element from the IBF, if possible.
+ *
+ * @param ibf the invertible bloom filter to decode
+ * @param ret_side sign of the cell's count where the decoded element came from.
+ *                 A negative sign indicates that the element was recovered
+ *                 resides in an IBF that was previously subtracted from.
+ * @param ret_id receives the hash code of the decoded element, if successful
+ * @return #GNUNET_YES if decoding an element was successful,
+ *         #GNUNET_NO if the IBF is empty,
+ *         #GNUNET_SYSERR if the decoding has failed
+ */
+int
+ibf_decode (struct InvertibleBloomFilter *ibf,
+            int *ret_side,
+            struct IBF_Key *ret_id);
+
+
+/**
+ * Create a copy of an IBF, the copy has to be destroyed properly.
+ *
+ * @param ibf the IBF to copy
+ */
+struct InvertibleBloomFilter *
+ibf_dup (const struct InvertibleBloomFilter *ibf);
+
+
+/**
+ * Destroy all resources associated with the invertible bloom filter.
+ * No more ibf_*-functions may be called on ibf after calling destroy.
+ *
+ * @param ibf the intertible bloom filter to destroy
+ */
+void
+ibf_destroy (struct InvertibleBloomFilter *ibf);
+
+
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/contrib/service/set/ibf_sim.c b/src/contrib/service/set/ibf_sim.c
new file mode 100644
index 000000000..563ed0fb8
--- /dev/null
+++ b/src/contrib/service/set/ibf_sim.c
@@ -0,0 +1,143 @@
+/*
+      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 set/ibf_sim.c
+ * @brief implementation of simulation for invertible bloom filter
+ * @author Florian Dold
+ *
+ * This code was used for some internal experiments, it is not
+ * build or shipped as part of the GNUnet system.
+ */
+#include "platform.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#define MAX_IBF_DECODE 16
+
+/* report average over how many rounds? */
+#define ROUNDS 100000
+
+/* enable one of the three below */
+// simple fix
+#define FIX1 0
+// possibly slightly better fix for large IBF_DECODE values
+#define FIX2 1
+
+// SIGCOMM algorithm
+#define STRATA 0
+
+// print each value?
+#define VERBOSE 0
+// avoid assembly? (ASM is about 50% faster)
+#define SLOW 0
+
+int
+main (int argc, char **argv)
+{
+  unsigned int round;
+  unsigned int buckets[31]; // max is 2^31 as 'random' returns only between 0 and 2^31
+  unsigned int i;
+  int j;
+  unsigned int r;
+  unsigned int ret;
+  unsigned long long total;
+  unsigned int want;
+  double predict;
+
+  srandom (time (NULL));
+  total = 0;
+  want = atoi (argv[1]);
+  for (round = 0; round < ROUNDS; round++)
+  {
+    memset (buckets, 0, sizeof(buckets));
+    for (i = 0; i < want; i++)
+    {
+      /* FIXME: might want to use 'better' PRNG to avoid
+         PRNG-induced biases */
+      r = random ();
+      if (0 == r)
+        continue;
+#if SLOW
+      for (j = 0; (j < 31) && (0 == (r & (1 << j))); j++)
+        ;
+#else
+      /* use assembly / gcc */
+      j = __builtin_ffs (r) - 1;
+#endif
+      buckets[j]++;
+    }
+    ret = 0;
+    predict = 0.0;
+    for (j = 31; j >= 0; j--)
+    {
+#if FIX1
+      /* improved algorithm, for 1000 elements with IBF-DECODE 8, I
+         get 990/1000 elements on average over 1 million runs; key
+         idea being to stop short of the 'last' possible IBF as
+         otherwise a "lowball" per-chance would unduely influence the
+         result */if ((j > 0) &&
+          (buckets[j - 1] > MAX_IBF_DECODE))
+      {
+        ret *= (1 << (j + 1));
+        break;
+      }
+#endif
+#if FIX2
+      /* another improvement: don't just always cut off the last one,
+         but rather try to predict based on all previous values where
+         that "last" one is; additional prediction can only really
+         work if MAX_IBF_DECODE is sufficiently high */
+      if ((j > 0) &&
+          ((buckets[j - 1] > MAX_IBF_DECODE) ||
+           (predict > MAX_IBF_DECODE)))
+      {
+        ret *= (1 << (j + 1));
+        break;
+      }
+#endif
+#if STRATA
+      /* original algorithm, for 1000 elements with IBF-DECODE 8,
+         I get 920/1000 elements on average over 1 million runs */
+      if (buckets[j] > MAX_IBF_DECODE)
+      {
+        ret *= (1 << (j + 1));
+        break;
+      }
+#endif
+      ret += buckets[j];
+      predict = (buckets[j] + 2.0 * predict) / 2.0;
+    }
+#if VERBOSE
+    fprintf (stderr, "%u ", ret);
+#endif
+    total += ret;
+  }
+  fprintf (stderr, "\n");
+  fprintf (stdout, "average %llu\n", total / ROUNDS);
+  return 0;
+}
+
+
+/* TODO: should calculate stddev of the results to also be able to
+   say something about the stability of the results, outside of
+   large-scale averages -- gaining 8% precision at the expense of
+   50% additional variance might not be worth it... */
diff --git a/src/contrib/service/set/meson.build b/src/contrib/service/set/meson.build
new file mode 100644
index 000000000..153c16ac5
--- /dev/null
+++ b/src/contrib/service/set/meson.build
@@ -0,0 +1,45 @@
+libgnunetset_src = ['set_api.c']
+
+gnunetserviceset_src = ['gnunet-service-set.c',
+                        'gnunet-service-set_union.c',
+                        'gnunet-service-set_intersection.c',
+                        'gnunet-service-set_union_strata_estimator.c',
+                        'ibf.c']
+
+configure_file(input : 'set.conf.in',
+               output : 'set.conf',
+               configuration : cdata,
+               install: true,
+               install_dir: pkgcfgdir)
+
+
+libgnunetset = library('gnunetset',
+        libgnunetset_src,
+        soversion: '0',
+        version: '0.0.0',
+        dependencies: libgnunetutil_dep,
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir'))
+pkg.generate(libgnunetset, url: 'https://www.gnunet.org',
+             description : 'Provides API for accessing the set service')
+libgnunetset_dep = declare_dependency(link_with : libgnunetset)
+shared_module('gnunet_plugin_block_set_test',
+              ['plugin_block_set_test.c'],
+              dependencies: libgnunetutil_dep,
+              include_directories: [incdir, configuration_inc],
+              install:true,
+              install_dir: get_option('libdir')/'gnunet')
+executable ('gnunet-service-set',
+            gnunetserviceset_src,
+            dependencies: [libgnunetset_dep,
+                           libgnunetutil_dep,
+                           m_dep,
+                           libgnunetstatistics_dep,
+                           libgnunetcore_dep,
+                           libgnunetcadet_dep,
+                           libgnunetblock_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+
diff --git a/src/contrib/service/set/plugin_block_set_test.c b/src/contrib/service/set/plugin_block_set_test.c
new file mode 100644
index 000000000..cb5cef5ad
--- /dev/null
+++ b/src/contrib/service/set/plugin_block_set_test.c
@@ -0,0 +1,167 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2017 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file set/plugin_block_set_test.c
+ * @brief set test block, recognizes elements with non-zero first byte as invalid
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_block_plugin.h"
+#include "gnunet_block_group_lib.h"
+
+
+/**
+ * Function called to validate a query.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param query original query (hash)
+ * @param xquery extrended query data (can be NULL, depending on type)
+ * @param xquery_size number of bytes in @a xquery
+ * @return #GNUNET_OK if the query is fine, #GNUNET_NO if not
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_set_test_check_query (void *cls,
+                                    enum GNUNET_BLOCK_Type type,
+                                    const struct GNUNET_HashCode *query,
+                                    const void *xquery,
+                                    size_t xquery_size)
+{
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function called to validate a block for storage.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param block block data to validate
+ * @param block_size number of bytes in @a block
+ * @return #GNUNET_OK if the block is fine, #GNUNET_NO if not
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_set_test_check_block (void *cls,
+                                    enum GNUNET_BLOCK_Type type,
+                                    const void *block,
+                                    size_t block_size)
+{
+  if ((NULL == block) ||
+      (0 == block_size) ||
+      (0 != ((char *) block)[0]))
+    return GNUNET_SYSERR;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function called to validate a reply to a request.  Note that it is assumed
+ * that the reply has already been matched to the key (and signatures checked)
+ * as it would be done with the GetKeyFunction and the
+ * BlockEvaluationFunction.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param group which block group to use for evaluation
+ * @param query original query (hash)
+ * @param xquery extrended query data (can be NULL, depending on type)
+ * @param xquery_size number of bytes in @a xquery
+ * @param reply_block response to validate
+ * @param reply_block_size number of bytes in @a reply_block
+ * @return characterization of result
+ */
+static enum GNUNET_BLOCK_ReplyEvaluationResult
+block_plugin_set_test_check_reply (void *cls,
+                                    enum GNUNET_BLOCK_Type type,
+                                    struct GNUNET_BLOCK_Group *group,
+                                    const struct GNUNET_HashCode *query,
+                                    const void *xquery,
+                                    size_t xquery_size,
+                                    const void *reply_block,
+                                    size_t reply_block_size)
+{
+  if ((NULL == reply_block) ||
+      (0 == reply_block_size) ||
+      (0 != ((char *) reply_block)[0]))
+    GNUNET_assert (0);
+  return GNUNET_BLOCK_REPLY_OK_MORE;
+}
+
+
+/**
+ * Function called to obtain the key for a block.
+ *
+ * @param cls closure
+ * @param type block type
+ * @param block block to get the key for
+ * @param block_size number of bytes in block
+ * @param key set to the key (query) for the given block
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if type not supported
+ *         (or if extracting a key from a block of this type does not work)
+ */
+static enum GNUNET_GenericReturnValue
+block_plugin_set_test_get_key (void *cls,
+                               enum GNUNET_BLOCK_Type type,
+                               const void *block,
+                               size_t block_size,
+                               struct GNUNET_HashCode *key)
+{
+  return GNUNET_NO;
+}
+
+
+/**
+ * Entry point for the plugin.
+ */
+void *
+libgnunet_plugin_block_set_test_init (void *cls)
+{
+  static const enum GNUNET_BLOCK_Type types[] = {
+    GNUNET_BLOCK_TYPE_SET_TEST,
+    GNUNET_BLOCK_TYPE_ANY       /* end of list */
+  };
+  struct GNUNET_BLOCK_PluginFunctions *api;
+
+  api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions);
+  api->get_key = &block_plugin_set_test_get_key;
+  api->check_query = &block_plugin_set_test_check_query;
+  api->check_block = &block_plugin_set_test_check_block;
+  api->check_reply = &block_plugin_set_test_check_reply;
+  api->types = types;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ */
+void *
+libgnunet_plugin_block_set_test_done (void *cls)
+{
+  struct GNUNET_BLOCK_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_block_set_test.c */
diff --git a/src/contrib/service/set/set.conf.in b/src/contrib/service/set/set.conf.in
new file mode 100644
index 000000000..66bcfa169
--- /dev/null
+++ b/src/contrib/service/set/set.conf.in
@@ -0,0 +1,12 @@
+[set]
+START_ON_DEMAND = @START_ON_DEMAND@
+@UNIXONLY@PORT = 2106
+HOSTNAME = localhost
+BINARY = gnunet-service-set
+ACCEPT_FROM = 127.0.0.1;
+ACCEPT_FROM6 = ::1;
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-set.sock
+UNIX_MATCH_UID = YES
+UNIX_MATCH_GID = YES
+
+#PREFIX = valgrind
diff --git a/src/contrib/service/set/set.h b/src/contrib/service/set/set.h
new file mode 100644
index 000000000..e9d10ea22
--- /dev/null
+++ b/src/contrib/service/set/set.h
@@ -0,0 +1,400 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2012-2014 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 set/set.h
+ * @brief messages used for the set api
+ * @author Florian Dold
+ * @author Christian Grothoff
+ */
+#ifndef SET_H
+#define SET_H
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_set_service.h"
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * Message sent by the client to the service to ask starting
+ * a new set to perform operations with.  Includes the desired
+ * set operation type.
+ */
+struct GNUNET_SET_CreateMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_CREATE
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Operation type, values of `enum GNUNET_SET_OperationType`
+   */
+  uint32_t operation GNUNET_PACKED;
+};
+
+
+/**
+ * Message sent by the client to the service to start listening for
+ * incoming requests to perform a certain type of set operation for a
+ * certain type of application.
+ */
+struct GNUNET_SET_ListenMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_LISTEN
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Operation type, values of `enum GNUNET_SET_OperationType`
+   */
+  uint32_t operation GNUNET_PACKED;
+
+  /**
+   * application id
+   */
+  struct GNUNET_HashCode app_id;
+};
+
+
+/**
+ * Message sent by a listening client to the service to accept
+ * performing the operation with the other peer.
+ */
+struct GNUNET_SET_AcceptMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_ACCEPT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * ID of the incoming request we want to accept.
+   */
+  uint32_t accept_reject_id GNUNET_PACKED;
+
+  /**
+   * Request ID to identify responses.
+   */
+  uint32_t request_id GNUNET_PACKED;
+
+  /**
+   * How should results be sent to us?
+   * See `enum GNUNET_SET_ResultMode`.
+   */
+  uint32_t result_mode GNUNET_PACKED;
+
+  /**
+   * Always use delta operation instead of sending full sets,
+   * even it it's less efficient.
+   */
+  uint8_t force_delta;
+
+  /**
+   * Always send full sets, even if delta operations would
+   * be more efficient.
+   */
+  uint8_t force_full;
+
+  /**
+   * #GNUNET_YES to fail operations where Byzantine faults
+   * are suspected
+   */
+  uint8_t byzantine;
+
+  /**
+   * Lower bound for the set size, used only when
+   * byzantine mode is enabled.
+   */
+  uint8_t byzantine_lower_bound;
+};
+
+
+/**
+ * Message sent by a listening client to the service to reject
+ * performing the operation with the other peer.
+ */
+struct GNUNET_SET_RejectMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_REJECT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * ID of the incoming request we want to reject.
+   */
+  uint32_t accept_reject_id GNUNET_PACKED;
+};
+
+
+/**
+ * A request for an operation with another client.
+ */
+struct GNUNET_SET_RequestMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_REQUEST.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * ID of the to identify the request when accepting or
+   * rejecting it.
+   */
+  uint32_t accept_id GNUNET_PACKED;
+
+  /**
+   * Identity of the requesting peer.
+   */
+  struct GNUNET_PeerIdentity peer_id;
+
+  /* rest: context message, that is, application-specific
+     message to convince listener to pick up */
+};
+
+
+/**
+ * Message sent by client to service to initiate a set operation as a
+ * client (not as listener).  A set (which determines the operation
+ * type) must already exist in association with this client.
+ */
+struct GNUNET_SET_EvaluateMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_EVALUATE
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * How should results be sent to us?
+   * See `enum GNUNET_SET_ResultMode`.
+   */
+  uint32_t result_mode GNUNET_PACKED;
+
+  /**
+   * Peer to evaluate the operation with
+   */
+  struct GNUNET_PeerIdentity target_peer;
+
+  /**
+   * Application id
+   */
+  struct GNUNET_HashCode app_id;
+
+  /**
+   * Id of our set to evaluate, chosen implicitly by the client when it
+   * calls #GNUNET_SET_commit().
+   */
+  uint32_t request_id GNUNET_PACKED;
+
+  /**
+   * Always use delta operation instead of sending full sets,
+   * even it it's less efficient.
+   */
+  uint8_t force_delta;
+
+  /**
+   * Always send full sets, even if delta operations would
+   * be more efficient.
+   */
+  uint8_t force_full;
+
+  /**
+   * #GNUNET_YES to fail operations where Byzantine faults
+   * are suspected
+   */
+  uint8_t byzantine;
+
+  /**
+   * Lower bound for the set size, used only when
+   * byzantine mode is enabled.
+   */
+  uint8_t byzantine_lower_bound;
+
+  /* rest: context message, that is, application-specific
+     message to convince listener to pick up */
+};
+
+
+/**
+ * Message sent by the service to the client to indicate an
+ * element that is removed (set intersection) or added
+ * (set union) or part of the final result, depending on
+ * options specified for the operation.
+ */
+struct GNUNET_SET_ResultMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_RESULT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Current set size.
+   */
+  uint64_t current_size;
+
+  /**
+   * id the result belongs to
+   */
+  uint32_t request_id GNUNET_PACKED;
+
+  /**
+   * Was the evaluation successful? Contains
+   * an `enum GNUNET_SET_Status` in NBO.
+   */
+  uint16_t result_status GNUNET_PACKED;
+
+  /**
+   * Type of the element attached to the message, if any.
+   */
+  uint16_t element_type GNUNET_PACKED;
+
+  /* rest: the actual element */
+};
+
+
+/**
+ * Message sent by client to the service to add or remove
+ * an element to/from the set.
+ */
+struct GNUNET_SET_ElementMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_ADD or
+   *       #GNUNET_MESSAGE_TYPE_SET_REMOVE
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Type of the element to add or remove.
+   */
+  uint16_t element_type GNUNET_PACKED;
+
+  /**
+   * For alignment, always zero.
+   */
+  uint16_t reserved GNUNET_PACKED;
+
+  /* rest: the actual element */
+};
+
+
+/**
+ * Sent to the service by the client
+ * in order to cancel a set operation.
+ */
+struct GNUNET_SET_CancelMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_CANCEL
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * ID of the request we want to cancel.
+   */
+  uint32_t request_id GNUNET_PACKED;
+};
+
+
+/**
+ * Set element transmitted by service to client in response to a set
+ * iteration request.
+ */
+struct GNUNET_SET_IterResponseMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * To which set iteration does this response belong to?  First
+   * iteration (per client) has counter zero. Wraps around.
+   */
+  uint16_t iteration_id GNUNET_PACKED;
+
+  /**
+   * Type of the element attached to the message,
+   * if any.
+   */
+  uint16_t element_type GNUNET_PACKED;
+
+  /* rest: element */
+};
+
+
+/**
+ * Client acknowledges receiving element in iteration.
+ */
+struct GNUNET_SET_IterAckMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_ITER_ACK
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Non-zero if the service should continue sending elements.
+   */
+  uint32_t send_more;
+};
+
+
+/**
+ * Server responds to a lazy copy request.
+ */
+struct GNUNET_SET_CopyLazyResponseMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_RESPONSE
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Temporary name for the copied set.
+   */
+  uint32_t cookie;
+};
+
+
+/**
+ * Client connects to a lazily copied set.
+ */
+struct GNUNET_SET_CopyLazyConnectMessage
+{
+  /**
+   * Type: #GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_CONNECT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Temporary name for the copied set.
+   */
+  uint32_t cookie;
+};
+
+
+GNUNET_NETWORK_STRUCT_END
+
+#endif
diff --git a/src/contrib/service/set/set_api.c b/src/contrib/service/set/set_api.c
new file mode 100644
index 000000000..4f73ff06c
--- /dev/null
+++ b/src/contrib/service/set/set_api.c
@@ -0,0 +1,1199 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2012-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 set/set_api.c
+ * @brief api for the set service
+ * @author Florian Dold
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_set_service.h"
+#include "set.h"
+
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "set-api", __VA_ARGS__)
+
+struct SetCopyRequest
+{
+  struct SetCopyRequest *next;
+
+  struct SetCopyRequest *prev;
+
+  void *cls;
+
+  GNUNET_SET_CopyReadyCallback cb;
+};
+
+/**
+ * Opaque handle to a set.
+ */
+struct GNUNET_SET_Handle
+{
+  /**
+   * Message queue for @e client.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Linked list of operations on the set.
+   */
+  struct GNUNET_SET_OperationHandle *ops_head;
+
+  /**
+   * Linked list of operations on the set.
+   */
+  struct GNUNET_SET_OperationHandle *ops_tail;
+
+  /**
+   * Callback for the current iteration over the set,
+   * NULL if no iterator is active.
+   */
+  GNUNET_SET_ElementIterator iterator;
+
+  /**
+   * Closure for @e iterator
+   */
+  void *iterator_cls;
+
+  /**
+   * Should the set be destroyed once all operations are gone?
+   * #GNUNET_SYSERR if #GNUNET_SET_destroy() must raise this flag,
+   * #GNUNET_YES if #GNUNET_SET_destroy() did raise this flag.
+   */
+  int destroy_requested;
+
+  /**
+   * Has the set become invalid (e.g. service died)?
+   */
+  int invalid;
+
+  /**
+   * Both client and service count the number of iterators
+   * created so far to match replies with iterators.
+   */
+  uint16_t iteration_id;
+
+  /**
+   * Configuration, needed when creating (lazy) copies.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Doubly linked list of copy requests.
+   */
+  struct SetCopyRequest *copy_req_head;
+
+  /**
+   * Doubly linked list of copy requests.
+   */
+  struct SetCopyRequest *copy_req_tail;
+};
+
+
+/**
+ * Handle for a set operation request from another peer.
+ */
+struct GNUNET_SET_Request
+{
+  /**
+   * Id of the request, used to identify the request when
+   * accepting/rejecting it.
+   */
+  uint32_t accept_id;
+
+  /**
+   * Has the request been accepted already?
+   * #GNUNET_YES/#GNUNET_NO
+   */
+  int accepted;
+};
+
+
+/**
+ * Handle to an operation.  Only known to the service after committing
+ * the handle with a set.
+ */
+struct GNUNET_SET_OperationHandle
+{
+  /**
+   * Function to be called when we have a result,
+   * or an error.
+   */
+  GNUNET_SET_ResultIterator result_cb;
+
+  /**
+   * Closure for @e result_cb.
+   */
+  void *result_cls;
+
+  /**
+   * Local set used for the operation,
+   * NULL if no set has been provided by conclude yet.
+   */
+  struct GNUNET_SET_Handle *set;
+
+  /**
+   * Message sent to the server on calling conclude,
+   * NULL if conclude has been called.
+   */
+  struct GNUNET_MQ_Envelope *conclude_mqm;
+
+  /**
+   * Address of the request if in the conclude message,
+   * used to patch the request id into the message when the set is known.
+   */
+  uint32_t *request_id_addr;
+
+  /**
+   * Handles are kept in a linked list.
+   */
+  struct GNUNET_SET_OperationHandle *prev;
+
+  /**
+   * Handles are kept in a linked list.
+   */
+  struct GNUNET_SET_OperationHandle *next;
+
+  /**
+   * Request ID to identify the operation within the set.
+   */
+  uint32_t request_id;
+};
+
+
+/**
+ * Opaque handle to a listen operation.
+ */
+struct GNUNET_SET_ListenHandle
+{
+  /**
+   * Message queue for the client.
+   */
+  struct GNUNET_MQ_Handle*mq;
+
+  /**
+   * Configuration handle for the listener, stored
+   * here to be able to reconnect transparently on
+   * connection failure.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Function to call on a new incoming request,
+   * or on error.
+   */
+  GNUNET_SET_ListenCallback listen_cb;
+
+  /**
+   * Closure for @e listen_cb.
+   */
+  void *listen_cls;
+
+  /**
+   * Application ID we listen for.
+   */
+  struct GNUNET_HashCode app_id;
+
+  /**
+   * Time to wait until we try to reconnect on failure.
+   */
+  struct GNUNET_TIME_Relative reconnect_backoff;
+
+  /**
+   * Task for reconnecting when the listener fails.
+   */
+  struct GNUNET_SCHEDULER_Task *reconnect_task;
+
+  /**
+   * Operation we listen for.
+   */
+  enum GNUNET_SET_OperationType operation;
+};
+
+
+/* mutual recursion with handle_copy_lazy */
+static struct GNUNET_SET_Handle *
+create_internal (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                 enum GNUNET_SET_OperationType op,
+                 const uint32_t *cookie);
+
+
+/**
+ * Handle element for iteration over the set.  Notifies the
+ * iterator and sends an acknowledgement to the service.
+ *
+ * @param cls the `struct GNUNET_SET_Handle *`
+ * @param msg the message
+ */
+static void
+handle_copy_lazy (void *cls,
+                  const struct GNUNET_SET_CopyLazyResponseMessage *msg)
+{
+  struct GNUNET_SET_Handle *set = cls;
+  struct SetCopyRequest *req;
+  struct GNUNET_SET_Handle *new_set;
+
+  req = set->copy_req_head;
+  if (NULL == req)
+  {
+    /* Service sent us unsolicited lazy copy response */
+    GNUNET_break (0);
+    return;
+  }
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Handling response to lazy copy\n");
+  GNUNET_CONTAINER_DLL_remove (set->copy_req_head,
+                               set->copy_req_tail,
+                               req);
+  // We pass none as operation here, since it doesn't matter when
+  // cloning.
+  new_set = create_internal (set->cfg,
+                             GNUNET_SET_OPERATION_NONE,
+                             &msg->cookie);
+  req->cb (req->cls, new_set);
+  GNUNET_free (req);
+}
+
+
+/**
+ * Check that the given @a msg is well-formed.
+ *
+ * @param cls closure
+ * @param msg message to check
+ * @return #GNUNET_OK if message is well-formed
+ */
+static int
+check_iter_element (void *cls,
+                    const struct GNUNET_SET_IterResponseMessage *msg)
+{
+  /* minimum size was already checked, everything else is OK! */
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle element for iteration over the set.  Notifies the
+ * iterator and sends an acknowledgement to the service.
+ *
+ * @param cls the `struct GNUNET_SET_Handle *`
+ * @param msg the message
+ */
+static void
+handle_iter_element (void *cls,
+                     const struct GNUNET_SET_IterResponseMessage *msg)
+{
+  struct GNUNET_SET_Handle *set = cls;
+  GNUNET_SET_ElementIterator iter = set->iterator;
+  struct GNUNET_SET_Element element;
+  struct GNUNET_SET_IterAckMessage *ack_msg;
+  struct GNUNET_MQ_Envelope *ev;
+  uint16_t msize;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received element in set iteration\n");
+  msize = ntohs (msg->header.size);
+  if (set->iteration_id != ntohs (msg->iteration_id))
+  {
+    /* element from a previous iteration, skip! */
+    iter = NULL;
+  }
+  if (NULL != iter)
+  {
+    element.size = msize - sizeof(struct GNUNET_SET_IterResponseMessage);
+    element.element_type = ntohs (msg->element_type);
+    element.data = &msg[1];
+    iter (set->iterator_cls,
+          &element);
+  }
+  ev = GNUNET_MQ_msg (ack_msg,
+                      GNUNET_MESSAGE_TYPE_SET_ITER_ACK);
+  ack_msg->send_more = htonl ((NULL != iter));
+  GNUNET_MQ_send (set->mq, ev);
+}
+
+
+/**
+ * Handle message signalling conclusion of iteration over the set.
+ * Notifies the iterator that we are done.
+ *
+ * @param cls the set
+ * @param mh the message
+ */
+static void
+handle_iter_done (void *cls,
+                  const struct GNUNET_MessageHeader *mh)
+{
+  struct GNUNET_SET_Handle *set = cls;
+  GNUNET_SET_ElementIterator iter = set->iterator;
+
+  if (NULL == iter)
+  {
+    /* FIXME: if this is true, could cancel+start a fresh one
+       cause elements to go to the wrong iteration? */
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "Service completed set iteration that was already cancelled\n");
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Set iteration completed\n");
+  set->destroy_requested = GNUNET_SYSERR;
+  set->iterator = NULL;
+  set->iteration_id++;
+  iter (set->iterator_cls,
+        NULL);
+  if (GNUNET_SYSERR == set->destroy_requested)
+    set->destroy_requested = GNUNET_NO;
+  if (GNUNET_YES == set->destroy_requested)
+    GNUNET_SET_destroy (set);
+}
+
+
+/**
+ * Check that the given @a msg is well-formed.
+ *
+ * @param cls closure
+ * @param msg message to check
+ * @return #GNUNET_OK if message is well-formed
+ */
+static int
+check_result (void *cls,
+              const struct GNUNET_SET_ResultMessage *msg)
+{
+  /* minimum size was already checked, everything else is OK! */
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle result message for a set operation.
+ *
+ * @param cls the set
+ * @param mh the message
+ */
+static void
+handle_result (void *cls,
+               const struct GNUNET_SET_ResultMessage *msg)
+{
+  struct GNUNET_SET_Handle *set = cls;
+  struct GNUNET_SET_OperationHandle *oh;
+  struct GNUNET_SET_Element e;
+  enum GNUNET_SET_Status result_status;
+  int destroy_set;
+
+  GNUNET_assert (NULL != set->mq);
+  result_status = (enum GNUNET_SET_Status) ntohs (msg->result_status);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Got result message with status %d\n",
+       result_status);
+
+  oh = GNUNET_MQ_assoc_get (set->mq,
+                            ntohl (msg->request_id));
+  if (NULL == oh)
+  {
+    /* 'oh' can be NULL if we canceled the operation, but the service
+       did not get the cancel message yet. */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Ignoring result from canceled operation\n");
+    return;
+  }
+
+  switch (result_status)
+  {
+  case GNUNET_SET_STATUS_OK:
+  case GNUNET_SET_STATUS_ADD_LOCAL:
+  case GNUNET_SET_STATUS_ADD_REMOTE:
+    goto do_element;
+
+  case GNUNET_SET_STATUS_FAILURE:
+  case GNUNET_SET_STATUS_DONE:
+    goto do_final;
+
+  case GNUNET_SET_STATUS_HALF_DONE:
+    /* not used anymore */
+    GNUNET_assert (0);
+  }
+
+do_final:
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Treating result as final status\n");
+  GNUNET_MQ_assoc_remove (set->mq,
+                          ntohl (msg->request_id));
+  GNUNET_CONTAINER_DLL_remove (set->ops_head,
+                               set->ops_tail,
+                               oh);
+  /* Need to do this calculation _before_ the result callback,
+     as IF the application still has a valid set handle, it
+     may trigger destruction of the set during the callback. */
+  destroy_set = (GNUNET_YES == set->destroy_requested) &&
+                (NULL == set->ops_head);
+  if (NULL != oh->result_cb)
+  {
+    oh->result_cb (oh->result_cls,
+                   NULL,
+                   GNUNET_ntohll (msg->current_size),
+                   result_status);
+  }
+  else
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "No callback for final status\n");
+  }
+  if (destroy_set)
+    GNUNET_SET_destroy (set);
+  GNUNET_free (oh);
+  return;
+
+do_element:
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Treating result as element\n");
+  e.data = &msg[1];
+  e.size = ntohs (msg->header.size) - sizeof(struct GNUNET_SET_ResultMessage);
+  e.element_type = ntohs (msg->element_type);
+  if (NULL != oh->result_cb)
+    oh->result_cb (oh->result_cls,
+                   &e,
+                   GNUNET_ntohll (msg->current_size),
+                   result_status);
+}
+
+
+/**
+ * Destroy the given set operation.
+ *
+ * @param oh set operation to destroy
+ */
+static void
+set_operation_destroy (struct GNUNET_SET_OperationHandle *oh)
+{
+  struct GNUNET_SET_Handle *set = oh->set;
+  struct GNUNET_SET_OperationHandle *h_assoc;
+
+  if (NULL != oh->conclude_mqm)
+    GNUNET_MQ_discard (oh->conclude_mqm);
+  /* is the operation already committed? */
+  if (NULL != set)
+  {
+    GNUNET_CONTAINER_DLL_remove (set->ops_head,
+                                 set->ops_tail,
+                                 oh);
+    h_assoc = GNUNET_MQ_assoc_remove (set->mq,
+                                      oh->request_id);
+    GNUNET_assert ((NULL == h_assoc) ||
+                   (h_assoc == oh));
+  }
+  GNUNET_free (oh);
+}
+
+
+/**
+ * Cancel the given set operation.  We need to send an explicit cancel
+ * message, as all operations one one set communicate using one
+ * handle.
+ *
+ * @param oh set operation to cancel
+ */
+void
+GNUNET_SET_operation_cancel (struct GNUNET_SET_OperationHandle *oh)
+{
+  struct GNUNET_SET_Handle *set = oh->set;
+  struct GNUNET_SET_CancelMessage *m;
+  struct GNUNET_MQ_Envelope *mqm;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Cancelling SET operation\n");
+  if (NULL != set)
+  {
+    mqm = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_SET_CANCEL);
+    m->request_id = htonl (oh->request_id);
+    GNUNET_MQ_send (set->mq, mqm);
+  }
+  set_operation_destroy (oh);
+  if ((NULL != set) &&
+      (GNUNET_YES == set->destroy_requested) &&
+      (NULL == set->ops_head))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Destroying set after operation cancel\n");
+    GNUNET_SET_destroy (set);
+  }
+}
+
+
+/**
+ * We encountered an error communicating with the set service while
+ * performing a set operation. Report to the application.
+ *
+ * @param cls the `struct GNUNET_SET_Handle`
+ * @param error error code
+ */
+static void
+handle_client_set_error (void *cls,
+                         enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_SET_Handle *set = cls;
+  GNUNET_SET_ElementIterator iter = set->iterator;
+
+  LOG (GNUNET_ERROR_TYPE_ERROR,
+       "Handling client set error %d\n",
+       error);
+  while (NULL != set->ops_head)
+  {
+    if ((NULL != set->ops_head->result_cb) &&
+        (GNUNET_NO == set->destroy_requested))
+      set->ops_head->result_cb (set->ops_head->result_cls,
+                                NULL,
+                                0,
+                                GNUNET_SET_STATUS_FAILURE);
+    set_operation_destroy (set->ops_head);
+  }
+  set->iterator = NULL;
+  set->iteration_id++;
+  set->invalid = GNUNET_YES;
+  if (NULL != iter)
+    iter (set->iterator_cls,
+          NULL);
+}
+
+
+/**
+ * FIXME.
+ */
+static struct GNUNET_SET_Handle *
+create_internal (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                 enum GNUNET_SET_OperationType op,
+                 const uint32_t *cookie)
+{
+  struct GNUNET_SET_Handle *set = GNUNET_new (struct GNUNET_SET_Handle);
+  struct GNUNET_MQ_MessageHandler mq_handlers[] = {
+    GNUNET_MQ_hd_var_size (result,
+                           GNUNET_MESSAGE_TYPE_SET_RESULT,
+                           struct GNUNET_SET_ResultMessage,
+                           set),
+    GNUNET_MQ_hd_var_size (iter_element,
+                           GNUNET_MESSAGE_TYPE_SET_ITER_ELEMENT,
+                           struct GNUNET_SET_IterResponseMessage,
+                           set),
+    GNUNET_MQ_hd_fixed_size (iter_done,
+                             GNUNET_MESSAGE_TYPE_SET_ITER_DONE,
+                             struct GNUNET_MessageHeader,
+                             set),
+    GNUNET_MQ_hd_fixed_size (copy_lazy,
+                             GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_RESPONSE,
+                             struct GNUNET_SET_CopyLazyResponseMessage,
+                             set),
+    GNUNET_MQ_handler_end ()
+  };
+  struct GNUNET_MQ_Envelope *mqm;
+  struct GNUNET_SET_CreateMessage *create_msg;
+  struct GNUNET_SET_CopyLazyConnectMessage *copy_msg;
+
+  set->cfg = cfg;
+  set->mq = GNUNET_CLIENT_connect (cfg,
+                                   "set",
+                                   mq_handlers,
+                                   &handle_client_set_error,
+                                   set);
+  if (NULL == set->mq)
+  {
+    GNUNET_free (set);
+    return NULL;
+  }
+  if (NULL == cookie)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Creating new set (operation %u)\n",
+         op);
+    mqm = GNUNET_MQ_msg (create_msg,
+                         GNUNET_MESSAGE_TYPE_SET_CREATE);
+    create_msg->operation = htonl (op);
+  }
+  else
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Creating new set (lazy copy)\n");
+    mqm = GNUNET_MQ_msg (copy_msg,
+                         GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_CONNECT);
+    copy_msg->cookie = *cookie;
+  }
+  GNUNET_MQ_send (set->mq,
+                  mqm);
+  return set;
+}
+
+
+/**
+ * Create an empty set, supporting the specified operation.
+ *
+ * @param cfg configuration to use for connecting to the
+ *        set service
+ * @param op operation supported by the set
+ *        Note that the operation has to be specified
+ *        beforehand, as certain set operations need to maintain
+ *        data structures specific to the operation
+ * @return a handle to the set
+ */
+struct GNUNET_SET_Handle *
+GNUNET_SET_create (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                   enum GNUNET_SET_OperationType op)
+{
+  struct GNUNET_SET_Handle *set;
+
+  set = create_internal (cfg,
+                         op,
+                         NULL);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Creating set %p for operation %d\n",
+       set,
+       op);
+  return set;
+}
+
+
+int
+GNUNET_SET_add_element (struct GNUNET_SET_Handle *set,
+                        const struct GNUNET_SET_Element *element,
+                        GNUNET_SET_Continuation cont,
+                        void *cont_cls)
+{
+  struct GNUNET_MQ_Envelope *mqm;
+  struct GNUNET_SET_ElementMessage *msg;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "adding element of type %u to set %p\n",
+       (unsigned int) element->element_type,
+       set);
+  GNUNET_assert (NULL != set);
+  if (GNUNET_YES == set->invalid)
+  {
+    if (NULL != cont)
+      cont (cont_cls);
+    return GNUNET_SYSERR;
+  }
+  mqm = GNUNET_MQ_msg_extra (msg,
+                             element->size,
+                             GNUNET_MESSAGE_TYPE_SET_ADD);
+  msg->element_type = htons (element->element_type);
+  GNUNET_memcpy (&msg[1],
+                 element->data,
+                 element->size);
+  GNUNET_MQ_notify_sent (mqm,
+                         cont, cont_cls);
+  GNUNET_MQ_send (set->mq, mqm);
+  return GNUNET_OK;
+}
+
+
+int
+GNUNET_SET_remove_element (struct GNUNET_SET_Handle *set,
+                           const struct GNUNET_SET_Element *element,
+                           GNUNET_SET_Continuation cont,
+                           void *cont_cls)
+{
+  struct GNUNET_MQ_Envelope *mqm;
+  struct GNUNET_SET_ElementMessage *msg;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Removing element from set %p\n",
+       set);
+  if (GNUNET_YES == set->invalid)
+  {
+    if (NULL != cont)
+      cont (cont_cls);
+    return GNUNET_SYSERR;
+  }
+  mqm = GNUNET_MQ_msg_extra (msg,
+                             element->size,
+                             GNUNET_MESSAGE_TYPE_SET_REMOVE);
+  msg->element_type = htons (element->element_type);
+  GNUNET_memcpy (&msg[1],
+                 element->data,
+                 element->size);
+  GNUNET_MQ_notify_sent (mqm,
+                         cont, cont_cls);
+  GNUNET_MQ_send (set->mq, mqm);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Destroy the set handle if no operations are left, mark the set
+ * for destruction otherwise.
+ *
+ * @param set set handle to destroy
+ */
+void
+GNUNET_SET_destroy (struct GNUNET_SET_Handle *set)
+{
+  /* destroying set while iterator is active is currently
+     not supported; we should expand the API to allow
+     clients to explicitly cancel the iteration! */
+  GNUNET_assert (NULL != set);
+  if ((NULL != set->ops_head) ||
+      (NULL != set->iterator) ||
+      (GNUNET_SYSERR == set->destroy_requested))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Set operations are pending, delaying set destruction\n");
+    set->destroy_requested = GNUNET_YES;
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Really destroying set\n");
+  if (NULL != set->mq)
+  {
+    GNUNET_MQ_destroy (set->mq);
+    set->mq = NULL;
+  }
+  GNUNET_free (set);
+}
+
+
+struct GNUNET_SET_OperationHandle *
+GNUNET_SET_prepare (const struct GNUNET_PeerIdentity *other_peer,
+                    const struct GNUNET_HashCode *app_id,
+                    const struct GNUNET_MessageHeader *context_msg,
+                    enum GNUNET_SET_ResultMode result_mode,
+                    struct GNUNET_SET_Option options[],
+                    GNUNET_SET_ResultIterator result_cb,
+                    void *result_cls)
+{
+  struct GNUNET_MQ_Envelope *mqm;
+  struct GNUNET_SET_OperationHandle *oh;
+  struct GNUNET_SET_EvaluateMessage *msg;
+  struct GNUNET_SET_Option *opt;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Client prepares set operation (%d)\n",
+       result_mode);
+  oh = GNUNET_new (struct GNUNET_SET_OperationHandle);
+  oh->result_cb = result_cb;
+  oh->result_cls = result_cls;
+  mqm = GNUNET_MQ_msg_nested_mh (msg,
+                                 GNUNET_MESSAGE_TYPE_SET_EVALUATE,
+                                 context_msg);
+  msg->app_id = *app_id;
+  msg->result_mode = htonl (result_mode);
+  msg->target_peer = *other_peer;
+  for (opt = options; opt->type != 0; opt++)
+  {
+    switch (opt->type)
+    {
+    case GNUNET_SET_OPTION_BYZANTINE:
+      msg->byzantine = GNUNET_YES;
+      msg->byzantine_lower_bound = opt->v.num;
+      break;
+
+    case GNUNET_SET_OPTION_FORCE_FULL:
+      msg->force_full = GNUNET_YES;
+      break;
+
+    case GNUNET_SET_OPTION_FORCE_DELTA:
+      msg->force_delta = GNUNET_YES;
+      break;
+
+    default:
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           "Option with type %d not recognized\n", (int) opt->type);
+    }
+  }
+  oh->conclude_mqm = mqm;
+  oh->request_id_addr = &msg->request_id;
+
+  return oh;
+}
+
+
+/**
+ * Connect to the set service in order to listen for requests.
+ *
+ * @param cls the `struct GNUNET_SET_ListenHandle *` to connect
+ */
+static void
+listen_connect (void *cls);
+
+
+/**
+ * Check validity of request message for a listen operation
+ *
+ * @param cls the listen handle
+ * @param msg the message
+ * @return #GNUNET_OK if the message is well-formed
+ */
+static int
+check_request (void *cls,
+               const struct GNUNET_SET_RequestMessage *msg)
+{
+  const struct GNUNET_MessageHeader *context_msg;
+
+  if (ntohs (msg->header.size) == sizeof(*msg))
+    return GNUNET_OK; /* no context message is OK */
+  context_msg = GNUNET_MQ_extract_nested_mh (msg);
+  if (NULL == context_msg)
+  {
+    /* malformed context message is NOT ok */
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle request message for a listen operation
+ *
+ * @param cls the listen handle
+ * @param msg the message
+ */
+static void
+handle_request (void *cls,
+                const struct GNUNET_SET_RequestMessage *msg)
+{
+  struct GNUNET_SET_ListenHandle *lh = cls;
+  struct GNUNET_SET_Request req;
+  const struct GNUNET_MessageHeader *context_msg;
+  struct GNUNET_MQ_Envelope *mqm;
+  struct GNUNET_SET_RejectMessage *rmsg;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Processing incoming operation request with id %u\n",
+       ntohl (msg->accept_id));
+  /* we got another valid request => reset the backoff */
+  lh->reconnect_backoff = GNUNET_TIME_UNIT_MILLISECONDS;
+  req.accept_id = ntohl (msg->accept_id);
+  req.accepted = GNUNET_NO;
+  context_msg = GNUNET_MQ_extract_nested_mh (msg);
+  /* calling #GNUNET_SET_accept() in the listen cb will set req->accepted */
+  lh->listen_cb (lh->listen_cls,
+                 &msg->peer_id,
+                 context_msg,
+                 &req);
+  if (GNUNET_YES == req.accepted)
+    return; /* the accept-case is handled in #GNUNET_SET_accept() */
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Rejected request %u\n",
+       ntohl (msg->accept_id));
+  mqm = GNUNET_MQ_msg (rmsg,
+                       GNUNET_MESSAGE_TYPE_SET_REJECT);
+  rmsg->accept_reject_id = msg->accept_id;
+  GNUNET_MQ_send (lh->mq, mqm);
+}
+
+
+/**
+ * Our connection with the set service encountered an error,
+ * re-initialize with exponential back-off.
+ *
+ * @param cls the `struct GNUNET_SET_ListenHandle *`
+ * @param error reason for the disconnect
+ */
+static void
+handle_client_listener_error (void *cls,
+                              enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_SET_ListenHandle *lh = cls;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Listener broke down (%d), re-connecting\n",
+       (int) error);
+  GNUNET_MQ_destroy (lh->mq);
+  lh->mq = NULL;
+  lh->reconnect_task = GNUNET_SCHEDULER_add_delayed (lh->reconnect_backoff,
+                                                     &listen_connect,
+                                                     lh);
+  lh->reconnect_backoff = GNUNET_TIME_STD_BACKOFF (lh->reconnect_backoff);
+}
+
+
+/**
+ * Connect to the set service in order to listen for requests.
+ *
+ * @param cls the `struct GNUNET_SET_ListenHandle *` to connect
+ */
+static void
+listen_connect (void *cls)
+{
+  struct GNUNET_SET_ListenHandle *lh = cls;
+  struct GNUNET_MQ_MessageHandler mq_handlers[] = {
+    GNUNET_MQ_hd_var_size (request,
+                           GNUNET_MESSAGE_TYPE_SET_REQUEST,
+                           struct GNUNET_SET_RequestMessage,
+                           lh),
+    GNUNET_MQ_handler_end ()
+  };
+  struct GNUNET_MQ_Envelope *mqm;
+  struct GNUNET_SET_ListenMessage *msg;
+
+  lh->reconnect_task = NULL;
+  GNUNET_assert (NULL == lh->mq);
+  lh->mq = GNUNET_CLIENT_connect (lh->cfg,
+                                  "set",
+                                  mq_handlers,
+                                  &handle_client_listener_error,
+                                  lh);
+  if (NULL == lh->mq)
+    return;
+  mqm = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_SET_LISTEN);
+  msg->operation = htonl (lh->operation);
+  msg->app_id = lh->app_id;
+  GNUNET_MQ_send (lh->mq,
+                  mqm);
+}
+
+
+/**
+ * Wait for set operation requests for the given application id
+ *
+ * @param cfg configuration to use for connecting to
+ *            the set service, needs to be valid for the lifetime of the listen handle
+ * @param operation operation we want to listen for
+ * @param app_id id of the application that handles set operation requests
+ * @param listen_cb called for each incoming request matching the operation
+ *                  and application id
+ * @param listen_cls handle for @a listen_cb
+ * @return a handle that can be used to cancel the listen operation
+ */
+struct GNUNET_SET_ListenHandle *
+GNUNET_SET_listen (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                   enum GNUNET_SET_OperationType operation,
+                   const struct GNUNET_HashCode *app_id,
+                   GNUNET_SET_ListenCallback listen_cb,
+                   void *listen_cls)
+{
+  struct GNUNET_SET_ListenHandle *lh;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Starting listener for app %s\n",
+       GNUNET_h2s (app_id));
+  lh = GNUNET_new (struct GNUNET_SET_ListenHandle);
+  lh->listen_cb = listen_cb;
+  lh->listen_cls = listen_cls;
+  lh->cfg = cfg;
+  lh->operation = operation;
+  lh->app_id = *app_id;
+  lh->reconnect_backoff = GNUNET_TIME_UNIT_MILLISECONDS;
+  listen_connect (lh);
+  if (NULL == lh->mq)
+  {
+    GNUNET_free (lh);
+    return NULL;
+  }
+  return lh;
+}
+
+
+/**
+ * Cancel the given listen operation.
+ *
+ * @param lh handle for the listen operation
+ */
+void
+GNUNET_SET_listen_cancel (struct GNUNET_SET_ListenHandle *lh)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Canceling listener %s\n",
+       GNUNET_h2s (&lh->app_id));
+  if (NULL != lh->mq)
+  {
+    GNUNET_MQ_destroy (lh->mq);
+    lh->mq = NULL;
+  }
+  if (NULL != lh->reconnect_task)
+  {
+    GNUNET_SCHEDULER_cancel (lh->reconnect_task);
+    lh->reconnect_task = NULL;
+  }
+  GNUNET_free (lh);
+}
+
+
+struct GNUNET_SET_OperationHandle *
+GNUNET_SET_accept (struct GNUNET_SET_Request *request,
+                   enum GNUNET_SET_ResultMode result_mode,
+                   struct GNUNET_SET_Option options[],
+                   GNUNET_SET_ResultIterator result_cb,
+                   void *result_cls)
+{
+  struct GNUNET_MQ_Envelope *mqm;
+  struct GNUNET_SET_OperationHandle *oh;
+  struct GNUNET_SET_AcceptMessage *msg;
+
+  GNUNET_assert (GNUNET_NO == request->accepted);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Client accepts set operation (%d) with id %u\n",
+       result_mode,
+       request->accept_id);
+  request->accepted = GNUNET_YES;
+  mqm = GNUNET_MQ_msg (msg,
+                       GNUNET_MESSAGE_TYPE_SET_ACCEPT);
+  msg->accept_reject_id = htonl (request->accept_id);
+  msg->result_mode = htonl (result_mode);
+  oh = GNUNET_new (struct GNUNET_SET_OperationHandle);
+  oh->result_cb = result_cb;
+  oh->result_cls = result_cls;
+  oh->conclude_mqm = mqm;
+  oh->request_id_addr = &msg->request_id;
+  return oh;
+}
+
+
+/**
+ * Commit a set to be used with a set operation.
+ * This function is called once we have fully constructed
+ * the set that we want to use for the operation.  At this
+ * time, the P2P protocol can then begin to exchange the
+ * set information and call the result callback with the
+ * result information.
+ *
+ * @param oh handle to the set operation
+ * @param set the set to use for the operation
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if the
+ *         set is invalid (e.g. the set service crashed)
+ */
+int
+GNUNET_SET_commit (struct GNUNET_SET_OperationHandle *oh,
+                   struct GNUNET_SET_Handle *set)
+{
+  if (NULL != oh->set)
+  {
+    /* Some other set was already committed for this
+     * operation, there is a logic bug in the client of this API */
+    GNUNET_break (0);
+    return GNUNET_OK;
+  }
+  GNUNET_assert (NULL != set);
+  if (GNUNET_YES == set->invalid)
+    return GNUNET_SYSERR;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Client commits to SET\n");
+  GNUNET_assert (NULL != oh->conclude_mqm);
+  oh->set = set;
+  GNUNET_CONTAINER_DLL_insert (set->ops_head,
+                               set->ops_tail,
+                               oh);
+  oh->request_id = GNUNET_MQ_assoc_add (set->mq,
+                                        oh);
+  *oh->request_id_addr = htonl (oh->request_id);
+  GNUNET_MQ_send (set->mq,
+                  oh->conclude_mqm);
+  oh->conclude_mqm = NULL;
+  oh->request_id_addr = NULL;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Iterate over all elements in the given set.  Note that this
+ * operation involves transferring every element of the set from the
+ * service to the client, and is thus costly.
+ *
+ * @param set the set to iterate over
+ * @param iter the iterator to call for each element
+ * @param iter_cls closure for @a iter
+ * @return #GNUNET_YES if the iteration started successfully,
+ *         #GNUNET_NO if another iteration is active
+ *         #GNUNET_SYSERR if the set is invalid (e.g. the server crashed, disconnected)
+ */
+int
+GNUNET_SET_iterate (struct GNUNET_SET_Handle *set,
+                    GNUNET_SET_ElementIterator iter,
+                    void *iter_cls)
+{
+  struct GNUNET_MQ_Envelope *ev;
+
+  GNUNET_assert (NULL != iter);
+  if (GNUNET_YES == set->invalid)
+    return GNUNET_SYSERR;
+  if (NULL != set->iterator)
+    return GNUNET_NO;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Iterating over set\n");
+  set->iterator = iter;
+  set->iterator_cls = iter_cls;
+  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_ITER_REQUEST);
+  GNUNET_MQ_send (set->mq, ev);
+  return GNUNET_YES;
+}
+
+
+void
+GNUNET_SET_copy_lazy (struct GNUNET_SET_Handle *set,
+                      GNUNET_SET_CopyReadyCallback cb,
+                      void *cls)
+{
+  struct GNUNET_MQ_Envelope *ev;
+  struct SetCopyRequest *req;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Creating lazy copy of set\n");
+  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_PREPARE);
+  GNUNET_MQ_send (set->mq, ev);
+
+  req = GNUNET_new (struct SetCopyRequest);
+  req->cb = cb;
+  req->cls = cls;
+  GNUNET_CONTAINER_DLL_insert (set->copy_req_head,
+                               set->copy_req_tail,
+                               req);
+}
+
+
+/**
+ * Create a copy of an element.  The copy
+ * must be GNUNET_free-d by the caller.
+ *
+ * @param element the element to copy
+ * @return the copied element
+ */
+struct GNUNET_SET_Element *
+GNUNET_SET_element_dup (const struct GNUNET_SET_Element *element)
+{
+  struct GNUNET_SET_Element *copy;
+
+  copy = GNUNET_malloc (element->size + sizeof(struct GNUNET_SET_Element));
+  copy->size = element->size;
+  copy->element_type = element->element_type;
+  copy->data = &copy[1];
+  GNUNET_memcpy (&copy[1],
+                 element->data,
+                 copy->size);
+  return copy;
+}
+
+
+void
+GNUNET_SET_element_hash (const struct GNUNET_SET_Element *element,
+                         struct GNUNET_HashCode *ret_hash)
+{
+  struct GNUNET_HashContext *ctx = GNUNET_CRYPTO_hash_context_start ();
+
+  /* It's not guaranteed that the element data is always after the element header,
+     so we need to hash the chunks separately. */
+  GNUNET_CRYPTO_hash_context_read (ctx, &element->size, sizeof(uint16_t));
+  GNUNET_CRYPTO_hash_context_read (ctx, &element->element_type,
+                                   sizeof(uint16_t));
+  GNUNET_CRYPTO_hash_context_read (ctx, element->data, element->size);
+  GNUNET_CRYPTO_hash_context_finish (ctx, ret_hash);
+}
+
+
+/* end of set_api.c */
diff --git a/src/contrib/service/set/test_set.conf b/src/contrib/service/set/test_set.conf
new file mode 100644
index 000000000..67d6f1bb7
--- /dev/null
+++ b/src/contrib/service/set/test_set.conf
@@ -0,0 +1,33 @@
+@INLINE@ ../../../contrib/conf/gnunet/no_forcestart.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-gnunet-set/
+
+[set]
+START_ON_DEMAND = YES
+#PREFIX = valgrind --leak-check=full
+#PREFIX = gdbserver :1234
+OPTIONS = -L INFO
+
+[transport]
+PLUGINS = unix
+OPTIONS = -LERROR
+
+[nat]
+RETURN_LOCAL_ADDRESSES = YES
+DISABLEV6 = YES
+USE_LOCALADDR = YES
+
+[peerinfo]
+NO_IO = YES
+
+[nat]
+# Use addresses from the local network interfaces (including loopback, but also others)
+USE_LOCALADDR = YES
+
+# Disable IPv6 support
+DISABLEV6 = NO
+
+# Do we use addresses from localhost address ranges? (::1, 127.0.0.0/8)
+RETURN_LOCAL_ADDRESSES = YES
+
diff --git a/src/contrib/service/set/test_set_api.c b/src/contrib/service/set/test_set_api.c
new file mode 100644
index 000000000..d1afdd354
--- /dev/null
+++ b/src/contrib/service/set/test_set_api.c
@@ -0,0 +1,403 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2012 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file set/test_set_api.c
+ * @brief testcase for set_api.c
+ * @author Florian Dold
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_set_service.h"
+
+
+static struct GNUNET_PeerIdentity local_id;
+
+static struct GNUNET_HashCode app_id;
+
+static struct GNUNET_SET_Handle *set1;
+
+static struct GNUNET_SET_Handle *set2;
+
+static struct GNUNET_SET_ListenHandle *listen_handle;
+
+static struct GNUNET_SET_OperationHandle *oh1;
+
+static struct GNUNET_SET_OperationHandle *oh2;
+
+static const struct GNUNET_CONFIGURATION_Handle *config;
+
+static unsigned int iter_count;
+
+static int ret;
+
+static struct GNUNET_SCHEDULER_Task *tt;
+
+
+static void
+result_cb_set1 (void *cls,
+                const struct GNUNET_SET_Element *element,
+                uint64_t size,
+                enum GNUNET_SET_Status status)
+{
+  switch (status)
+  {
+  case GNUNET_SET_STATUS_OK:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 1: got element\n");
+    break;
+
+  case GNUNET_SET_STATUS_FAILURE:
+    GNUNET_break (0);
+    oh1 = NULL;
+    fprintf (stderr, "set 1: received failure status!\n");
+    ret = 1;
+    if (NULL != tt)
+    {
+      GNUNET_SCHEDULER_cancel (tt);
+      tt = NULL;
+    }
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  case GNUNET_SET_STATUS_DONE:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 1: done\n");
+    oh1 = NULL;
+    if (NULL != set1)
+    {
+      GNUNET_SET_destroy (set1);
+      set1 = NULL;
+    }
+    if (NULL == set2)
+    {
+      GNUNET_SCHEDULER_cancel (tt);
+      tt = NULL;
+      GNUNET_SCHEDULER_shutdown ();
+    }
+    break;
+
+  default:
+    GNUNET_assert (0);
+  }
+}
+
+
+static void
+result_cb_set2 (void *cls,
+                const struct GNUNET_SET_Element *element,
+                uint64_t size,
+                enum GNUNET_SET_Status status)
+{
+  switch (status)
+  {
+  case GNUNET_SET_STATUS_OK:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 2: got element\n");
+    break;
+
+  case GNUNET_SET_STATUS_FAILURE:
+    GNUNET_break (0);
+    oh2 = NULL;
+    fprintf (stderr, "set 2: received failure status\n");
+    GNUNET_SCHEDULER_shutdown ();
+    ret = 1;
+    break;
+
+  case GNUNET_SET_STATUS_DONE:
+    oh2 = NULL;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "set 2: done\n");
+    GNUNET_SET_destroy (set2);
+    set2 = NULL;
+    if (NULL == set1)
+    {
+      GNUNET_SCHEDULER_cancel (tt);
+      tt = NULL;
+      GNUNET_SCHEDULER_shutdown ();
+    }
+    break;
+
+  default:
+    GNUNET_assert (0);
+  }
+}
+
+
+static void
+listen_cb (void *cls,
+           const struct GNUNET_PeerIdentity *other_peer,
+           const struct GNUNET_MessageHeader *context_msg,
+           struct GNUNET_SET_Request *request)
+{
+  GNUNET_assert (NULL != context_msg);
+  GNUNET_assert (ntohs (context_msg->type) == GNUNET_MESSAGE_TYPE_DUMMY);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "listen cb called\n");
+  oh2 = GNUNET_SET_accept (request,
+                           GNUNET_SET_RESULT_ADDED,
+                           (struct GNUNET_SET_Option[]){ 0 },
+                           &result_cb_set2,
+                           NULL);
+  GNUNET_SET_commit (oh2, set2);
+}
+
+
+/**
+ * Start the set operation.
+ *
+ * @param cls closure, unused
+ */
+static void
+start (void *cls)
+{
+  struct GNUNET_MessageHeader context_msg;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting reconciliation\n");
+  context_msg.size = htons (sizeof context_msg);
+  context_msg.type = htons (GNUNET_MESSAGE_TYPE_DUMMY);
+  listen_handle = GNUNET_SET_listen (config,
+                                     GNUNET_SET_OPERATION_UNION,
+                                     &app_id,
+                                     &listen_cb,
+                                     NULL);
+  oh1 = GNUNET_SET_prepare (&local_id,
+                            &app_id,
+                            &context_msg,
+                            GNUNET_SET_RESULT_ADDED,
+                            (struct GNUNET_SET_Option[]){ 0 },
+                            &result_cb_set1,
+                            NULL);
+  GNUNET_SET_commit (oh1, set1);
+}
+
+
+/**
+ * Initialize the second set, continue
+ *
+ * @param cls closure, unused
+ */
+static void
+init_set2 (void *cls)
+{
+  struct GNUNET_SET_Element element;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initializing set 2\n");
+
+  element.element_type = 0;
+  element.data = "hello";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (set2, &element, NULL, NULL);
+  element.data = "quux";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (set2, &element, NULL, NULL);
+  element.data = "baz";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (set2, &element, &start, NULL);
+}
+
+
+/**
+ * Initialize the first set, continue.
+ */
+static void
+init_set1 (void)
+{
+  struct GNUNET_SET_Element element;
+
+  element.element_type = 0;
+  element.data = "hello";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (set1, &element, NULL, NULL);
+  element.data = "bar";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (set1, &element, &init_set2, NULL);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "initialized set 1\n");
+}
+
+
+static int
+iter_cb (void *cls, const struct GNUNET_SET_Element *element)
+{
+  struct GNUNET_SET_Handle *set = cls;
+
+  if (NULL == element)
+  {
+    GNUNET_assert (3 == iter_count);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Iteration finished, destroying set %p\n",
+                set);
+    GNUNET_SET_destroy (set);
+    return GNUNET_YES;
+  }
+  iter_count++;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "iter: got element %u\n", iter_count);
+  return GNUNET_YES;
+}
+
+
+static void
+test_iter ()
+{
+  struct GNUNET_SET_Element element;
+  struct GNUNET_SET_Handle *iter_set;
+
+  iter_set = GNUNET_SET_create (config, GNUNET_SET_OPERATION_UNION);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Testing iteration over 3 elements on set %p\n",
+              iter_set);
+  element.element_type = 0;
+
+  element.data = "hello";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (iter_set, &element, NULL, NULL);
+  element.data = "bar";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (iter_set, &element, NULL, NULL);
+  element.data = "quux";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (iter_set, &element, NULL, NULL);
+  GNUNET_SET_iterate (iter_set, &iter_cb, iter_set);
+}
+
+
+/**
+ * Function run on timeout.
+ *
+ * @param cls closure
+ */
+static void
+timeout_fail (void *cls)
+{
+  tt = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Testcase failed with timeout\n");
+  GNUNET_SCHEDULER_shutdown ();
+  ret = 1;
+}
+
+
+/**
+ * Function run on shutdown.
+ *
+ * @param cls closure
+ */
+static void
+do_shutdown (void *cls)
+{
+  if (NULL != tt)
+  {
+    GNUNET_SCHEDULER_cancel (tt);
+    tt = NULL;
+  }
+  if (NULL != oh1)
+  {
+    GNUNET_SET_operation_cancel (oh1);
+    oh1 = NULL;
+  }
+  if (NULL != oh2)
+  {
+    GNUNET_SET_operation_cancel (oh2);
+    oh2 = NULL;
+  }
+  if (NULL != set1)
+  {
+    GNUNET_SET_destroy (set1);
+    set1 = NULL;
+  }
+  if (NULL != set2)
+  {
+    GNUNET_SET_destroy (set2);
+    set2 = NULL;
+  }
+  if (NULL != listen_handle)
+  {
+    GNUNET_SET_listen_cancel (listen_handle);
+    listen_handle = NULL;
+  }
+}
+
+
+/**
+ * Signature of the 'main' function for a (single-peer) testcase that
+ * is run using 'GNUNET_TESTING_peer_run'.
+ *
+ * @param cls closure
+ * @param cfg configuration of the peer that was started
+ * @param peer identity of the peer that was created
+ */
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
+{
+  struct GNUNET_SET_OperationHandle *my_oh;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Running preparatory tests\n");
+  tt = GNUNET_SCHEDULER_add_delayed (
+    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5),
+    &timeout_fail,
+    NULL);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+
+  config = cfg;
+  GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_get_peer_identity (cfg, &local_id));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "my id (from CRYPTO): %s\n",
+              GNUNET_i2s (&local_id));
+  GNUNET_TESTING_peer_get_identity (peer, &local_id);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "my id (from TESTING): %s\n",
+              GNUNET_i2s (&local_id));
+  test_iter ();
+
+  set1 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION);
+  set2 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Created sets %p and %p for union operation\n",
+              set1,
+              set2);
+  GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &app_id);
+
+  /* test if canceling an uncommitted request works! */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Launching and instantly stopping set operation\n");
+  my_oh = GNUNET_SET_prepare (&local_id,
+                              &app_id,
+                              NULL,
+                              GNUNET_SET_RESULT_ADDED,
+                              (struct GNUNET_SET_Option[]){ 0 },
+                              NULL,
+                              NULL);
+  GNUNET_SET_operation_cancel (my_oh);
+
+  /* test the real set reconciliation */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Running real set-reconciliation\n");
+  init_set1 ();
+}
+
+
+int
+main (int argc, char **argv)
+{
+  GNUNET_log_setup ("test_set_api", "WARNING", NULL);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Launching peer\n");
+  if (0 !=
+      GNUNET_TESTING_peer_run ("test_set_api", "test_set.conf", &run, NULL))
+  {
+    return 1;
+  }
+  return ret;
+}
diff --git a/src/contrib/service/set/test_set_intersection_result_full.c b/src/contrib/service/set/test_set_intersection_result_full.c
new file mode 100644
index 000000000..42dedb846
--- /dev/null
+++ b/src/contrib/service/set/test_set_intersection_result_full.c
@@ -0,0 +1,393 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2012-2014 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 set/test_set_intersection_result_full.c
+ * @brief testcase for full result mode of the intersection set operation
+ * @author Christian Fuchs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_set_service.h"
+
+
+static int ret;
+
+static struct GNUNET_PeerIdentity local_id;
+
+static struct GNUNET_HashCode app_id;
+
+static struct GNUNET_SET_Handle *set1;
+
+static struct GNUNET_SET_Handle *set2;
+
+static struct GNUNET_SET_ListenHandle *listen_handle;
+
+static const struct GNUNET_CONFIGURATION_Handle *config;
+
+static int iter_count;
+
+static struct GNUNET_SCHEDULER_Task *tt;
+
+static struct GNUNET_SET_OperationHandle *oh1;
+
+static struct GNUNET_SET_OperationHandle *oh2;
+
+
+static void
+result_cb_set1 (void *cls,
+                const struct GNUNET_SET_Element *element,
+                uint64_t current_size,
+                enum GNUNET_SET_Status status)
+{
+  static int count;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Processing result set 1 (%d)\n",
+              status);
+  switch (status)
+  {
+  case GNUNET_SET_STATUS_OK:
+    count++;
+    break;
+
+  case GNUNET_SET_STATUS_FAILURE:
+    oh1 = NULL;
+    ret = 1;
+    break;
+
+  case GNUNET_SET_STATUS_DONE:
+    oh1 = NULL;
+    GNUNET_assert (1 == count);
+    GNUNET_SET_destroy (set1);
+    set1 = NULL;
+    if (NULL == set2)
+      GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  default:
+    GNUNET_assert (0);
+  }
+}
+
+
+static void
+result_cb_set2 (void *cls,
+                const struct GNUNET_SET_Element *element,
+                uint64_t current_size,
+                enum GNUNET_SET_Status status)
+{
+  static int count;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Processing result set 2 (%d)\n",
+              status);
+  switch (status)
+  {
+  case GNUNET_SET_STATUS_OK:
+    count++;
+    break;
+
+  case GNUNET_SET_STATUS_FAILURE:
+    oh2 = NULL;
+    ret = 1;
+    break;
+
+  case GNUNET_SET_STATUS_DONE:
+    oh2 = NULL;
+    GNUNET_assert (1 == count);
+    GNUNET_SET_destroy (set2);
+    set2 = NULL;
+    if (NULL == set1)
+      GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  default:
+    GNUNET_assert (0);
+  }
+}
+
+
+static void
+listen_cb (void *cls,
+           const struct GNUNET_PeerIdentity *other_peer,
+           const struct GNUNET_MessageHeader *context_msg,
+           struct GNUNET_SET_Request *request)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "starting intersection by accepting and committing\n");
+  GNUNET_assert (NULL != context_msg);
+  GNUNET_assert (ntohs (context_msg->type) == GNUNET_MESSAGE_TYPE_DUMMY);
+  oh2 = GNUNET_SET_accept (request,
+                           GNUNET_SET_RESULT_FULL,
+                           (struct GNUNET_SET_Option[]) { 0 },
+                           &result_cb_set2,
+                           NULL);
+  GNUNET_SET_commit (oh2,
+                     set2);
+}
+
+
+/**
+ * Start the set operation.
+ *
+ * @param cls closure, unused
+ */
+static void
+start (void *cls)
+{
+  struct GNUNET_MessageHeader context_msg;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "starting listener\n");
+  context_msg.size = htons (sizeof context_msg);
+  context_msg.type = htons (GNUNET_MESSAGE_TYPE_DUMMY);
+  listen_handle = GNUNET_SET_listen (config,
+                                     GNUNET_SET_OPERATION_INTERSECTION,
+                                     &app_id,
+                                     &listen_cb,
+                                     NULL);
+  oh1 = GNUNET_SET_prepare (&local_id,
+                            &app_id,
+                            &context_msg,
+                            GNUNET_SET_RESULT_FULL,
+                            (struct GNUNET_SET_Option[]) { 0 },
+                            &result_cb_set1,
+                            NULL);
+  GNUNET_SET_commit (oh1,
+                     set1);
+}
+
+
+/**
+ * Initialize the second set, continue
+ *
+ * @param cls closure, unused
+ */
+static void
+init_set2 (void *cls)
+{
+  struct GNUNET_SET_Element element;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "initializing set 2\n");
+  element.element_type = 0;
+  element.data = "hello";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (set2,
+                          &element,
+                          NULL,
+                          NULL);
+  element.data = "quux";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (set2,
+                          &element,
+                          NULL,
+                          NULL);
+  element.data = "baz";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (set2,
+                          &element,
+                          &start,
+                          NULL);
+}
+
+
+/**
+ * Initialize the first set, continue.
+ */
+static void
+init_set1 (void)
+{
+  struct GNUNET_SET_Element element;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "initializing set 1\n");
+  element.element_type = 0;
+  element.data = "hello";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (set1,
+                          &element,
+                          NULL,
+                          NULL);
+  element.data = "bar";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (set1,
+                          &element,
+                          &init_set2,
+                          NULL);
+}
+
+
+static int
+iter_cb (void *cls,
+         const struct GNUNET_SET_Element *element)
+{
+  if (NULL == element)
+  {
+    GNUNET_assert (iter_count == 3);
+    GNUNET_SET_destroy (cls);
+    return GNUNET_YES;
+  }
+  iter_count++;
+  return GNUNET_YES;
+}
+
+
+static void
+test_iter ()
+{
+  struct GNUNET_SET_Element element;
+  struct GNUNET_SET_Handle *iter_set;
+
+  iter_set = GNUNET_SET_create (config,
+                                GNUNET_SET_OPERATION_INTERSECTION);
+  element.element_type = 0;
+  element.data = "hello";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (iter_set,
+                          &element,
+                          NULL,
+                          NULL);
+  element.data = "bar";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (iter_set,
+                          &element,
+                          NULL,
+                          NULL);
+  element.data = "quux";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (iter_set,
+                          &element,
+                          NULL,
+                          NULL);
+  GNUNET_SET_iterate (iter_set,
+                      &iter_cb,
+                      iter_set);
+}
+
+
+/**
+ * Function run on shutdown.
+ *
+ * @param cls closure
+ */
+static void
+do_shutdown (void *cls)
+{
+  if (NULL != tt)
+  {
+    GNUNET_SCHEDULER_cancel (tt);
+    tt = NULL;
+  }
+  if (NULL != oh1)
+  {
+    GNUNET_SET_operation_cancel (oh1);
+    oh1 = NULL;
+  }
+  if (NULL != oh2)
+  {
+    GNUNET_SET_operation_cancel (oh2);
+    oh2 = NULL;
+  }
+  if (NULL != set1)
+  {
+    GNUNET_SET_destroy (set1);
+    set1 = NULL;
+  }
+  if (NULL != set2)
+  {
+    GNUNET_SET_destroy (set2);
+    set2 = NULL;
+  }
+  if (NULL != listen_handle)
+  {
+    GNUNET_SET_listen_cancel (listen_handle);
+    listen_handle = NULL;
+  }
+}
+
+
+/**
+ * Function run on timeout.
+ *
+ * @param cls closure
+ */
+static void
+timeout_fail (void *cls)
+{
+  tt = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
+              "Testcase failed with timeout\n");
+  GNUNET_SCHEDULER_shutdown ();
+  ret = 1;
+}
+
+
+/**
+ * Signature of the 'main' function for a (single-peer) testcase that
+ * is run using 'GNUNET_TESTING_peer_run'.
+ *
+ * @param cls closure
+ * @param cfg configuration of the peer that was started
+ * @param peer identity of the peer that was created
+ */
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
+{
+  config = cfg;
+  GNUNET_TESTING_peer_get_identity (peer,
+                                    &local_id);
+  if (0)
+    test_iter ();
+
+  tt = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (
+                                       GNUNET_TIME_UNIT_SECONDS, 5),
+                                     &timeout_fail,
+                                     NULL);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
+                                 NULL);
+
+  set1 = GNUNET_SET_create (cfg,
+                            GNUNET_SET_OPERATION_INTERSECTION);
+  set2 = GNUNET_SET_create (cfg,
+                            GNUNET_SET_OPERATION_INTERSECTION);
+  GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK,
+                                    &app_id);
+
+  /* test the real set reconciliation */
+  init_set1 ();
+}
+
+
+int
+main (int argc,
+      char **argv)
+{
+  if (0 != GNUNET_TESTING_peer_run ("test_set_intersection_result_full",
+                                    "test_set.conf",
+                                    &run, NULL))
+    return 1;
+  return ret;
+}
diff --git a/src/contrib/service/set/test_set_union_copy.c b/src/contrib/service/set/test_set_union_copy.c
new file mode 100644
index 000000000..908527017
--- /dev/null
+++ b/src/contrib/service/set/test_set_union_copy.c
@@ -0,0 +1,311 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2015, 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 set/test_set_union_copy.c
+ * @brief testcase for lazy copying of union sets
+ * @author Florian Dold
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_common.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_set_service.h"
+
+
+/**
+ * Value to return from #main().
+ */
+static int ret;
+
+static struct GNUNET_PeerIdentity local_id;
+
+static struct GNUNET_SET_Handle *set1;
+
+static struct GNUNET_SET_Handle *set2;
+
+static const struct GNUNET_CONFIGURATION_Handle *config;
+
+static struct GNUNET_SCHEDULER_Task *tt;
+
+
+static void
+add_element_str (struct GNUNET_SET_Handle *set,
+                 char *str)
+{
+  struct GNUNET_SET_Element element;
+
+  element.element_type = 0;
+  element.data = str;
+  element.size = strlen (str);
+  GNUNET_SET_add_element (set,
+                          &element,
+                          NULL,
+                          NULL);
+}
+
+
+static void
+remove_element_str (struct GNUNET_SET_Handle *set,
+                    char *str)
+{
+  struct GNUNET_SET_Element element;
+
+  element.element_type = 0;
+  element.data = str;
+  element.size = strlen (str);
+  GNUNET_SET_remove_element (set,
+                             &element,
+                             NULL,
+                             NULL);
+}
+
+
+/**
+ * Signature of the main function of a task.
+ *
+ * @param cls closure
+ */
+static void
+timeout_fail (void *cls)
+{
+  tt = NULL;
+  GNUNET_SCHEDULER_shutdown ();
+  ret = 1;
+}
+
+
+struct CountIterClosure
+{
+  unsigned int expected_count;
+  unsigned int ongoing_count;
+  GNUNET_SCHEDULER_TaskCallback cont;
+  void *cont_cls;
+  char *what;
+};
+
+
+static int
+check_count_iter (void *cls,
+                  const struct GNUNET_SET_Element *element)
+{
+  struct CountIterClosure *ci_cls = cls;
+
+  if (NULL == element)
+  {
+    if (ci_cls->expected_count != ci_cls->ongoing_count)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Expected count (what: %s) to be %u, but it's actually %u\n",
+                  ci_cls->what,
+                  ci_cls->expected_count,
+                  ci_cls->ongoing_count);
+      ret = 1;
+      GNUNET_SCHEDULER_shutdown ();
+      return GNUNET_NO;
+    }
+    ci_cls->cont (ci_cls->cont_cls);
+    GNUNET_free (ci_cls);
+    return GNUNET_NO;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Set `%s' has element %.*s\n",
+              ci_cls->what,
+              (int) element->size,
+              (const char *) element->data);
+
+  ci_cls->ongoing_count++;
+  return GNUNET_YES;
+}
+
+
+static void
+check_count (struct GNUNET_SET_Handle *set,
+             char *what,
+             unsigned int expected_count,
+             GNUNET_SCHEDULER_TaskCallback cont,
+             void *cont_cls)
+{
+  struct CountIterClosure *ci_cls = GNUNET_new (struct CountIterClosure);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Checking count of %s\n",
+              what);
+
+  ci_cls->expected_count = expected_count;
+  ci_cls->ongoing_count = 0;
+  ci_cls->cont = cont;
+  ci_cls->cont_cls = cont_cls;
+  ci_cls->what = what;
+
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_SET_iterate (set,
+                                     &check_count_iter,
+                                     ci_cls));
+}
+
+
+static void
+test_done (void *cls)
+{
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+static void
+check_new_set_count (void *cls)
+{
+  check_count (set2,
+               "new set",
+               3,
+               &test_done,
+               NULL);
+}
+
+
+static void
+copy_done (void *cls,
+           struct GNUNET_SET_Handle *new_set)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "copy done\n");
+  set2 = new_set;
+  remove_element_str (set2,
+                      "k5555");
+  add_element_str (set2,
+                   "n66666");
+  add_element_str (set2,
+                   "new2butremoved");
+  remove_element_str (set2,
+                      "new2butremoved");
+  remove_element_str (set2,
+                      "new3justremoved");
+  // Check that set1 didn't change.
+  check_count (set1,
+               "old set",
+               3,
+               &check_new_set_count,
+               NULL);
+}
+
+
+static void
+test_copy (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "about to copy\n");
+  GNUNET_SET_copy_lazy (set1,
+                        &copy_done,
+                        NULL);
+}
+
+
+/**
+ * Function run on shutdown.
+ *
+ * @param cls closure
+ */
+static void
+do_shutdown (void *cls)
+{
+  if (NULL != tt)
+  {
+    GNUNET_SCHEDULER_cancel (tt);
+    tt = NULL;
+  }
+  if (NULL != set1)
+  {
+    GNUNET_SET_destroy (set1);
+    set1 = NULL;
+  }
+  if (NULL != set2)
+  {
+    GNUNET_SET_destroy (set2);
+    set2 = NULL;
+  }
+}
+
+
+/**
+ * Signature of the 'main' function for a (single-peer) testcase that
+ * is run using #GNUNET_TESTING_peer_run().
+ *
+ * @param cls closure
+ * @param cfg configuration of the peer that was started
+ * @param peer identity of the peer that was created
+ */
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
+{
+  tt = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (
+                                       GNUNET_TIME_UNIT_SECONDS, 5),
+                                     &timeout_fail,
+                                     NULL);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
+                                 NULL);
+  config = cfg;
+  GNUNET_TESTING_peer_get_identity (peer,
+                                    &local_id);
+
+  set1 = GNUNET_SET_create (cfg,
+                            GNUNET_SET_OPERATION_UNION);
+  add_element_str (set1,
+                   "333");
+  add_element_str (set1,
+                   "k444");
+  /* duplicate -- ignored */
+  add_element_str (set1,
+                   "k444");
+  remove_element_str (set1,
+                      "333");
+  /* non-existent -- ignored */
+  remove_element_str (set1,
+                      "999999999");
+  add_element_str (set1,
+                   "k5555");
+  /* duplicate -- ignored */
+  remove_element_str (set1,
+                      "333");
+  add_element_str (set1,
+                   "k2");
+
+  check_count (set1,
+               "initial test",
+               3,
+               &test_copy,
+               NULL);
+}
+
+
+int
+main (int argc, char **argv)
+{
+  if (0 != GNUNET_TESTING_peer_run ("test_set_union_copy",
+                                    "test_set.conf",
+                                    &run, NULL))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "failed to start testing peer\n");
+    return 1;
+  }
+  return ret;
+}
diff --git a/src/contrib/service/set/test_set_union_result_symmetric.c b/src/contrib/service/set/test_set_union_result_symmetric.c
new file mode 100644
index 000000000..b6c7a82f6
--- /dev/null
+++ b/src/contrib/service/set/test_set_union_result_symmetric.c
@@ -0,0 +1,455 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2012, 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 set/test_set_union_result_smmetric
+ * @brief testcase for symmetric result mode of the union set operation
+ * @author Florian Dold
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_set_service.h"
+
+
+/**
+ * Value to return from #main().
+ */
+static int ret;
+
+static struct GNUNET_PeerIdentity local_id;
+
+static struct GNUNET_HashCode app_id;
+
+static struct GNUNET_SET_Handle *set1;
+
+static struct GNUNET_SET_Handle *set2;
+
+static struct GNUNET_SET_ListenHandle *listen_handle;
+
+static const struct GNUNET_CONFIGURATION_Handle *config;
+
+static struct GNUNET_SET_OperationHandle *oh1;
+
+static struct GNUNET_SET_OperationHandle *oh2;
+
+static int iter_count;
+
+/**
+ * Are we testing correctness for the empty set union?
+ */
+static int empty;
+
+/**
+ * Number of elements found in set 1
+ */
+static unsigned int count_set1;
+
+/**
+ * Number of elements found in set 2
+ */
+static unsigned int count_set2;
+
+/**
+ * Task that is run when the test times out.
+ */
+static struct GNUNET_SCHEDULER_Task *timeout_task;
+
+
+static void
+result_cb_set1 (void *cls,
+                const struct GNUNET_SET_Element *element,
+                uint64_t current_size,
+                enum GNUNET_SET_Status status)
+{
+  switch (status)
+  {
+  case GNUNET_SET_STATUS_ADD_LOCAL:
+    count_set1++;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "set 1: got element\n");
+    break;
+
+  case GNUNET_SET_STATUS_FAILURE:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "set 1: failure\n");
+    oh1 = NULL;
+    ret = 1;
+    if (NULL != timeout_task)
+    {
+      GNUNET_SCHEDULER_cancel (timeout_task);
+      timeout_task = NULL;
+    }
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  case GNUNET_SET_STATUS_DONE:
+    oh1 = NULL;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "set 1: done\n");
+    GNUNET_SET_destroy (set1);
+    set1 = NULL;
+    if (NULL == set2)
+    {
+      if (NULL != timeout_task)
+      {
+        GNUNET_SCHEDULER_cancel (timeout_task);
+        timeout_task = NULL;
+      }
+      GNUNET_SCHEDULER_shutdown ();
+    }
+    break;
+
+  case GNUNET_SET_STATUS_ADD_REMOTE:
+    break;
+
+  default:
+    GNUNET_assert (0);
+  }
+}
+
+
+static void
+result_cb_set2 (void *cls,
+                const struct GNUNET_SET_Element *element,
+                uint64_t current_size,
+                enum GNUNET_SET_Status status)
+{
+  switch (status)
+  {
+  case GNUNET_SET_STATUS_ADD_LOCAL:
+    count_set2++;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "set 2: got element\n");
+    break;
+
+  case GNUNET_SET_STATUS_FAILURE:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "set 2: failure\n");
+    oh2 = NULL;
+    ret = 1;
+    if (NULL != timeout_task)
+    {
+      GNUNET_SCHEDULER_cancel (timeout_task);
+      timeout_task = NULL;
+    }
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  case GNUNET_SET_STATUS_DONE:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "set 2: done\n");
+    oh2 = NULL;
+    GNUNET_SET_destroy (set2);
+    set2 = NULL;
+    if (NULL == set1)
+    {
+      if (NULL != timeout_task)
+      {
+        GNUNET_SCHEDULER_cancel (timeout_task);
+        timeout_task = NULL;
+      }
+      GNUNET_SCHEDULER_shutdown ();
+    }
+    break;
+
+  case GNUNET_SET_STATUS_ADD_REMOTE:
+    break;
+
+  default:
+    GNUNET_assert (0);
+  }
+}
+
+
+static void
+listen_cb (void *cls,
+           const struct GNUNET_PeerIdentity *other_peer,
+           const struct GNUNET_MessageHeader *context_msg,
+           struct GNUNET_SET_Request *request)
+{
+  GNUNET_assert (NULL != context_msg);
+  GNUNET_assert (ntohs (context_msg->type) == GNUNET_MESSAGE_TYPE_DUMMY);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "listen cb called\n");
+  oh2 = GNUNET_SET_accept (request,
+                           GNUNET_SET_RESULT_SYMMETRIC,
+                           (struct GNUNET_SET_Option[]) { 0 },
+                           &result_cb_set2,
+                           NULL);
+  GNUNET_SET_commit (oh2,
+                     set2);
+}
+
+
+/**
+ * Start the set operation.
+ *
+ * @param cls closure, unused
+ */
+static void
+start (void *cls)
+{
+  struct GNUNET_MessageHeader context_msg;
+
+  context_msg.size = htons (sizeof context_msg);
+  context_msg.type = htons (GNUNET_MESSAGE_TYPE_DUMMY);
+
+  listen_handle = GNUNET_SET_listen (config,
+                                     GNUNET_SET_OPERATION_UNION,
+                                     &app_id,
+                                     &listen_cb, NULL);
+  oh1 = GNUNET_SET_prepare (&local_id,
+                            &app_id,
+                            &context_msg,
+                            GNUNET_SET_RESULT_SYMMETRIC,
+                            (struct GNUNET_SET_Option[]) { 0 },
+                            &result_cb_set1, NULL);
+  GNUNET_SET_commit (oh1, set1);
+}
+
+
+/**
+ * Initialize the second set, continue
+ *
+ * @param cls closure, unused
+ */
+static void
+init_set2 (void *cls)
+{
+  struct GNUNET_SET_Element element;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "initializing set 2\n");
+  if (empty)
+  {
+    start (NULL);
+    return;
+  }
+  element.element_type = 0;
+  element.data = "hello";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (set2,
+                          &element,
+                          NULL,
+                          NULL);
+  element.data = "quux";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (set2,
+                          &element,
+                          NULL,
+                          NULL);
+  element.data = "baz";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (set2,
+                          &element,
+                          &start, NULL);
+}
+
+
+/**
+ * Initialize the first set, continue.
+ */
+static void
+init_set1 (void)
+{
+  struct GNUNET_SET_Element element;
+
+  if (empty)
+  {
+    init_set2 (NULL);
+    return;
+  }
+  element.element_type = 0;
+  element.data = "hello";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (set1,
+                          &element,
+                          NULL,
+                          NULL);
+  element.data = "bar";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (set1,
+                          &element,
+                          &init_set2,
+                          NULL);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "initialized set 1\n");
+}
+
+
+static int
+iter_cb (void *cls,
+         const struct GNUNET_SET_Element *element)
+{
+  if (NULL == element)
+  {
+    GNUNET_assert (iter_count == 3);
+    GNUNET_SET_destroy (cls);
+    return GNUNET_YES;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "iter: got element\n");
+  iter_count++;
+  return GNUNET_YES;
+}
+
+
+static void
+test_iter ()
+{
+  struct GNUNET_SET_Element element;
+  struct GNUNET_SET_Handle *iter_set;
+
+  iter_count = 0;
+  iter_set = GNUNET_SET_create (config, GNUNET_SET_OPERATION_UNION);
+  element.element_type = 0;
+  element.data = "hello";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (iter_set, &element, NULL, NULL);
+  element.data = "bar";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (iter_set, &element, NULL, NULL);
+  element.data = "quux";
+  element.size = strlen (element.data);
+  GNUNET_SET_add_element (iter_set, &element, NULL, NULL);
+
+  GNUNET_SET_iterate (iter_set,
+                      &iter_cb,
+                      iter_set);
+}
+
+
+/**
+ * Signature of the main function of a task.
+ *
+ * @param cls closure
+ */
+static void
+timeout_fail (void *cls)
+{
+  timeout_task = NULL;
+  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "test timed out\n");
+  ret = 1;
+}
+
+
+/**
+ * Function run on shutdown.
+ *
+ * @param cls closure
+ */
+static void
+do_shutdown (void *cls)
+{
+  if (NULL != timeout_task)
+  {
+    GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = NULL;
+  }
+  if (NULL != oh1)
+  {
+    GNUNET_SET_operation_cancel (oh1);
+    oh1 = NULL;
+  }
+  if (NULL != oh2)
+  {
+    GNUNET_SET_operation_cancel (oh2);
+    oh2 = NULL;
+  }
+  if (NULL != set1)
+  {
+    GNUNET_SET_destroy (set1);
+    set1 = NULL;
+  }
+  if (NULL != set2)
+  {
+    GNUNET_SET_destroy (set2);
+    set2 = NULL;
+  }
+  if (NULL != listen_handle)
+  {
+    GNUNET_SET_listen_cancel (listen_handle);
+    listen_handle = NULL;
+  }
+}
+
+
+/**
+ * Signature of the 'main' function for a (single-peer) testcase that
+ * is run using 'GNUNET_TESTING_peer_run'.
+ *
+ * @param cls closure
+ * @param cfg configuration of the peer that was started
+ * @param peer identity of the peer that was created
+ */
+static void
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
+{
+  timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (
+                                                 GNUNET_TIME_UNIT_SECONDS, 5),
+                                               &timeout_fail,
+                                               NULL);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
+                                 NULL);
+  config = cfg;
+  GNUNET_TESTING_peer_get_identity (peer,
+                                    &local_id);
+
+  if (0)
+    test_iter ();
+
+  set1 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION);
+  set2 = GNUNET_SET_create (cfg, GNUNET_SET_OPERATION_UNION);
+  GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &app_id);
+
+  /* test the real set reconciliation */
+  init_set1 ();
+}
+
+
+int
+main (int argc, char **argv)
+{
+  empty = 1;
+  if (0 != GNUNET_TESTING_peer_run ("test_set_api",
+                                    "test_set.conf",
+                                    &run, NULL))
+  {
+    return 1;
+  }
+  GNUNET_assert (0 == count_set1);
+  GNUNET_assert (0 == count_set2);
+  empty = 0;
+  if (0 != GNUNET_TESTING_peer_run ("test_set_api",
+                                    "test_set.conf",
+                                    &run, NULL))
+  {
+    return 1;
+  }
+  GNUNET_break (2 == count_set1);
+  GNUNET_break (1 == count_set2);
+  return ret;
+}
diff --git a/src/contrib/service/template/.gitignore b/src/contrib/service/template/.gitignore
new file mode 100644
index 000000000..8ac4bacb5
--- /dev/null
+++ b/src/contrib/service/template/.gitignore
@@ -0,0 +1,3 @@
+gnunet-template
+gnunet-service-template
+test_template_api
diff --git a/src/contrib/service/template/Makefile.am b/src/contrib/service/template/Makefile.am
new file mode 100644
index 000000000..4661266d7
--- /dev/null
+++ b/src/contrib/service/template/Makefile.am
@@ -0,0 +1,41 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+dist_pkgcfg_DATA = \
+  template.conf
+
+if USE_COVERAGE
+  AM_CFLAGS = -fprofile-arcs -ftest-coverage
+endif
+
+# Note: In a real installation,
+# bin_PROGRAMS should be used for gnunet-template
+# libexec_PROGRAMS should be used for gnunet-service-template
+
+noinst_PROGRAMS = \
+ gnunet-service-template
+
+
+gnunet_service_template_SOURCES = \
+ gnunet-service-template.c
+gnunet_service_template_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(GN_LIBINTL)
+
+
+check_PROGRAMS = \
+ test_template_api
+
+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_template_api_SOURCES = \
+ test_template_api.c
+test_template_api_LDADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
diff --git a/src/contrib/service/template/gnunet-service-template.c b/src/contrib/service/template/gnunet-service-template.c
new file mode 100644
index 000000000..e04d2f61d
--- /dev/null
+++ b/src/contrib/service/template/gnunet-service-template.c
@@ -0,0 +1,104 @@
+/*
+     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 template/gnunet-service-template.c
+ * @brief program that does template
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+
+
+/**
+ * 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 template 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 ("template",
+                     GNUNET_SERVICE_OPTION_NONE,
+                     &run,
+                     &client_connect_cb,
+                     &client_disconnect_cb,
+                     NULL,
+                     GNUNET_MQ_handler_end ());
+
+
+/* end of gnunet-service-template.c */
diff --git a/src/contrib/service/template/meson.build b/src/contrib/service/template/meson.build
new file mode 100644
index 000000000..414abc880
--- /dev/null
+++ b/src/contrib/service/template/meson.build
@@ -0,0 +1,19 @@
+gnunetservicetemplate_src = ['gnunet-service-template.c']
+
+configure_file(input : 'template.conf',
+               output : 'template.conf',
+               configuration : cdata,
+               install: false)
+
+executable ('gnunet-service-template',
+            gnunetservicetemplate_src,
+            dependencies: [libgnunetutil_dep],
+            include_directories: [incdir, configuration_inc],
+            install: false)
+testtemplateapi = executable ('test_template_api',
+            ['test_template_api.c'],
+            dependencies: [libgnunetutil_dep],
+            include_directories: [incdir, configuration_inc],
+            install: false)
+test('test_template_api', testtemplateapi, workdir: meson.current_source_dir(),
+     suite: ['template', 'contrib'])
diff --git a/src/contrib/service/template/template.conf b/src/contrib/service/template/template.conf
new file mode 100644
index 000000000..24b123390
--- /dev/null
+++ b/src/contrib/service/template/template.conf
@@ -0,0 +1,23 @@
+[template]
+START_ON_DEMAND = NO
+# for tests please come up with numbers that are
+# unlikely to be in use by anyone. we typically
+# use five digit numbers < 65536 with no "beauty"
+# (no repetitions, no sequences, no popularity).
+PORT = 99999
+HOSTNAME = localhost
+BINARY = gnunet-service-template
+ACCEPT_FROM = 127.0.0.1;
+ACCEPT_FROM6 = ::1;
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-template.sock
+UNIX_MATCH_UID = YES
+UNIX_MATCH_GID = YES
+# DISABLE_SOCKET_FORWARDING = NO
+# USERNAME = 
+# MAXBUF =
+# TIMEOUT =
+# DISABLEV6 =
+# BINDTO =
+# REJECT_FROM =
+# REJECT_FROM6 =
+# PREFIX =
diff --git a/src/contrib/service/template/test_template_api.c b/src/contrib/service/template/test_template_api.c
new file mode 100644
index 000000000..196edec2d
--- /dev/null
+++ b/src/contrib/service/template/test_template_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 template/test_template_api.c
+ * @brief testcase for template.c
+ */
+#include "platform.h"
+
+static int
+check ()
+{
+  return 0;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int ret;
+
+  ret = check ();
+
+  return ret;
+}
+
+
+/* end of test_template_api.c */