124 files changed, 44204 insertions, 0 deletions

diff --git a/src/service/transport/.gitignore b/src/service/transport/.gitignore
new file mode 100644
index 000000000..163ffbd5d
--- /dev/null
+++ b/src/service/transport/.gitignore
@@ -0,0 +1,94 @@
+gnunet-transport-wlan-sender
+gnunet-helper-transport-bluetooth
+gnunet-helper-transport-wlan
+gnunet-helper-transport-wlan-dummy
+gnunet-service-transport
+gnunet-transport
+gnunet-transport-certificate-creation
+gnunet-transport-profiler
+gnunet-transport-wlan-receiver
+https_cert_qutoa_p2.crt
+https_key_quota_p2.key
+test_http_common
+test_plugin_bluetooth
+test_plugin_http_client
+test_plugin_http_server
+test_plugin_https_client
+test_plugin_https_server
+test_plugin_tcp
+test_plugin_udp
+test_plugin_unix
+test_plugin_wlan
+test_quota_compliance_bluetooth
+test_quota_compliance_bluetooth_asymmetric
+test_quota_compliance_http
+test_quota_compliance_http_asymmetric
+test_quota_compliance_https
+test_quota_compliance_https_asymmetric
+test_quota_compliance_tcp
+test_quota_compliance_tcp_asymmetric
+test_quota_compliance_udp
+test_quota_compliance_unix
+test_quota_compliance_unix_asymmetric
+test_quota_compliance_wlan
+test_quota_compliance_wlan_asymmetric
+test_transport_address_switch_http
+test_transport_address_switch_https
+test_transport_address_switch_tcp
+test_transport_address_switch_udp
+test_transport_api_blacklisting_tcp
+test_transport_api_bluetooth
+test_transport_api_disconnect_tcp
+test_transport_api_http
+test_transport_api_http_reverse
+test_transport_api_https
+test_transport_api_limited_sockets_tcp
+test_transport_api_manipulation_cfg
+test_transport_api_manipulation_recv_tcp
+test_transport_api_manipulation_send_tcp
+test_transport_api_monitor_peers
+test_transport_api_multi
+test_transport_api_reliability_bluetooth
+test_transport_api_reliability_http
+test_transport_api_reliability_http_xhr
+test_transport_api_reliability_https
+test_transport_api_reliability_https_xhr
+test_transport_api_reliability_tcp
+test_transport_api_reliability_tcp_nat
+test_transport_api_reliability_udp
+test_transport_api_reliability_unix
+test_transport_api_reliability_wlan
+test_transport_api_restart_1peer
+test_transport_api_restart_2peers
+test_transport_api_slow_ats
+test_transport_api_tcp
+test_transport_api_tcp_nat
+test_transport_api_timeout_bluetooth
+test_transport_api_timeout_http
+test_transport_api_timeout_https
+test_transport_api_timeout_tcp
+test_transport_api_timeout_udp
+test_transport_api_timeout_unix
+test_transport_api_timeout_wlan
+test_transport_api_udp
+test_transport_api_udp_nat
+test_transport_api_unix
+test_transport_api_unix_abstract
+test_transport_api_wlan
+test_transport_blacklisting_inbound_bl_full
+test_transport_blacklisting_inbound_bl_plugin
+test_transport_blacklisting_multiple_plugins
+test_transport_blacklisting_no_bl
+test_transport_blacklisting_outbound_bl_full
+test_transport_blacklisting_outbound_bl_plugin
+test_transport_testing_restart
+test_transport_testing_startstop
+gnunet-communicator-unix
+gnunet-service-tng
+gnunet-communicator-tcp
+gnunet-communicator-udp
+test_communicator_basic-*
+test_communicator_rekey-*
+test_transport_start_with_config
+test_transport_api2_tcp
+gnunet-communicator-quic
diff --git a/src/service/transport/Makefile.am b/src/service/transport/Makefile.am
new file mode 100644
index 000000000..d25dc296f
--- /dev/null
+++ b/src/service/transport/Makefile.am
@@ -0,0 +1,446 @@
+# This Makefile.am is in the public domain
+AM_CPPFLAGS = -I$(top_srcdir)/src/include -I$(top_builddir)/src/include
+
+plugindir = $(libdir)/gnunet
+
+pkgcfgdir= $(pkgdatadir)/config.d/
+
+libexecdir= $(pkglibdir)/libexec/
+
+pkgcfg_DATA = \
+  transport.conf
+
+if USE_COVERAGE
+  AM_CFLAGS = --coverage -O0
+endif
+
+noinst_PROGRAMS = \
+ gnunet-communicator-udp
+
+TESTING_LIBS = \
+  libgnunettestingtransport.la
+
+lib_LTLIBRARIES = \
+  libgnunettransportapplication.la \
+  libgnunettransportcore.la \
+  libgnunettransportcommunicator.la \
+  libgnunettransportmonitor.la \
+  $(TESTING_LIBS)
+
+libgnunettestingtransport_la_SOURCES = \
+  testing_transport_traits.c
+#  transport_api_cmd_connecting_peers.c \
+#  transport_api_cmd_backchannel_check.c \
+#  transport_api_cmd_send_simple.c \
+#  transport_api_cmd_send_simple_performance.c \
+#  transport-testing2.c transport-testing2.h \
+#  transport-testing-cmds.h \
+#  transport-testing-filenames2.c \
+#  transport-testing-loggers2.c \
+#  transport-testing-main2.c \
+#  transport-testing-send2.c \
+#  transport-testing-communicator.c transport-testing-communicator.h
+libgnunettestingtransport_la_LIBADD = \
+  libgnunettransportapplication.la \
+  libgnunettransportcore.la \
+  $(top_builddir)/src/service/testbed/libgnunettestbed.la \
+  $(top_builddir)/src/service/arm/libgnunetarm.la \
+  $(top_builddir)/src/lib/testing/libgnunettesting.la \
+  $(top_builddir)/src/lib/hello/libgnunethello.la \
+  $(top_builddir)/src/service/peerstore/libgnunetpeerstore.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
+libgnunettransporttesting2_la_LDFLAGS = \
+  $(GN_LIBINTL) \
+  $(GN_LIB_LDFLAGS) \
+  -version-info 0:0:0
+
+libgnunettransportapplication_la_SOURCES = \
+  transport_api2_application.c
+libgnunettransportapplication_la_LIBADD = \
+ $(top_builddir)/src/lib/util/libgnunetutil.la \
+ $(LTLIBINTL)
+libgnunettransportapplication_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)  \
+  -version-info 0:0:0
+
+
+libgnunettransportcore_la_SOURCES = \
+  transport_api2_core.c
+libgnunettransportcore_la_LIBADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(GN_LIBINTL)
+libgnunettransportcore_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)  \
+  -version-info 0:0:0
+
+libgnunettransportcommunicator_la_SOURCES = \
+  transport_api2_communication.c
+libgnunettransportcommunicator_la_LIBADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(GN_LIBINTL)
+libgnunettransportcommunicator_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)  \
+  -version-info 0:0:0
+
+
+libgnunettransportmonitor_la_SOURCES = \
+  transport_api2_monitor.c
+libgnunettransportmonitor_la_LIBADD = \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(GN_LIBINTL)
+libgnunettransportmonitor_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS)  \
+  -version-info 0:0:0
+
+
+libexec_PROGRAMS = \
+ gnunet-service-transport \
+ gnunet-communicator-unix \
+ gnunet-communicator-udp \
+ gnunet-communicator-tcp
+if HAVE_EXPERIMENTAL
+if HAVE_QUICHE
+libexec_PROGRAMS += \
+ gnunet-communicator-quic
+endif
+endif
+
+
+#bin_PROGRAMS = \
+# gnunet-transport
+
+bin_SCRIPTS = \
+ gnunet-transport-certificate-creation
+
+# See: https://www.gnu.org/software/automake/manual/html_node/Scripts.html#Scripts
+do_subst = sed -e 's,[@]pkgdatadir[@],$(pkgdatadir),g'
+
+
+gnunet-transport-certificate-creation: gnunet-transport-certificate-creation.in Makefile
+        $(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 < $(srcdir)/gnunet-transport-certificate-creation.in > gnunet-transport-certificate-creation
+        @chmod +x gnunet-transport-certificate-creation
+
+
+
+
+gnunet_communicator_unix_SOURCES = \
+ gnunet-communicator-unix.c
+gnunet_communicator_unix_LDADD = \
+  libgnunettransportcommunicator.la \
+  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la
+
+gnunet_communicator_tcp_SOURCES = \
+ gnunet-communicator-tcp.c
+gnunet_communicator_tcp_LDADD = \
+  libgnunettransportcommunicator.la \
+  $(top_builddir)/src/service/peerstore/libgnunetpeerstore.la \
+  $(top_builddir)/src/service/nat/libgnunetnatnew.la \
+  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LIBGCRYPT_LIBS)
+
+gnunet_communicator_udp_SOURCES = \
+ gnunet-communicator-udp.c
+gnunet_communicator_udp_LDADD = \
+  libgnunettransportapplication.la \
+  libgnunettransportcommunicator.la \
+  $(top_builddir)/src/service/nat/libgnunetnatnew.la \
+  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LIBGCRYPT_LIBS)
+
+if HAVE_EXPERIMENTAL
+if HAVE_QUICHE
+gnunet_communicator_quic_SOURCES = \
+  gnunet-communicator-quic.c
+gnunet_communicator_quic_LDADD = \
+  libgnunettransportapplication.la \
+  libgnunettransportcommunicator.la \
+  $(top_builddir)/src/service/peerstore/libgnunetpeerstore.la \
+  $(top_builddir)/src/service/nat/libgnunetnatnew.la \
+  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  -lquiche \
+  $(LIBGCRYPT_LIBS)
+endif
+endif
+
+#gnunet_transport_SOURCES = \
+# gnunet-transport.c
+#gnunet_transport_LDADD = \
+#  libgnunettransport.la \
+#  $(top_builddir)/src/lib/hello/libgnunethello.la \
+#  $(top_builddir)/src/lib/util/libgnunetutil.la \
+#  $(GN_LIBINTL)
+
+gnunet_service_transport_SOURCES = \
+ gnunet-service-transport.c transport.h
+gnunet_service_transport_LDADD = \
+  $(top_builddir)/src/service/peerstore/libgnunetpeerstore.la \
+  $(top_builddir)/src/lib/hello/libgnunethello.la \
+  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(top_builddir)/src/service/nat/libgnunetnatnew.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LIBGCRYPT_LIBS) \
+  $(GN_LIBINTL)
+
+#plugin_LTLIBRARIES = \
+#  libgnunet_test_transport_plugin_cmd_simple_send_performance.la \
+#  libgnunet_test_transport_plugin_cmd_nat_upnp.la \
+#  libgnunet_test_transport_plugin_cmd_simple_send.la \
+#  libgnunet_test_transport_plugin_cmd_simple_send_broadcast.la \
+#  libgnunet_test_transport_plugin_cmd_simple_send_dv.la \
+#  libgnunet_test_transport_plugin_cmd_udp_backchannel.la
+
+libgnunet_test_transport_plugin_cmd_nat_upnp_la_SOURCES = \
+ test_transport_plugin_cmd_nat_upnp.c
+libgnunet_test_transport_plugin_cmd_nat_upnp_la_LIBADD = \
+  libgnunettransporttesting2.la \
+  libgnunettransportapplication.la \
+  libgnunettransportcore.la \
+  $(top_builddir)/src/lib/testing/libgnunettesting.la \
+  $(top_builddir)/src/service/peerstore/libgnunetpeerstore.la \
+  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(top_builddir)/src/lib/hello/libgnunethello.la \
+  $(top_builddir)/src/service/arm/libgnunetarm.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunet_test_transport_plugin_cmd_nat_upnp_la_LDFLAGS = \
+  $(GN_PLUGIN_LDFLAGS)
+
+libgnunet_test_transport_plugin_cmd_udp_backchannel_la_SOURCES = \
+ test_transport_plugin_cmd_udp_backchannel.c
+libgnunet_test_transport_plugin_cmd_udp_backchannel_la_LIBADD = \
+  libgnunettransporttesting2.la \
+  libgnunettransportapplication.la \
+  libgnunettransportcore.la \
+  $(top_builddir)/src/lib/testing/libgnunettesting.la \
+  $(top_builddir)/src/service/peerstore/libgnunetpeerstore.la \
+  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(top_builddir)/src/lib/hello/libgnunethello.la \
+  $(top_builddir)/src/service/arm/libgnunetarm.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunet_test_transport_plugin_cmd_udp_backchannel_la_LDFLAGS = \
+  $(GN_PLUGIN_LDFLAGS)
+
+libgnunet_test_transport_plugin_cmd_simple_send_la_SOURCES = \
+ test_transport_plugin_cmd_simple_send.c
+libgnunet_test_transport_plugin_cmd_simple_send_la_LIBADD = \
+  libgnunettransporttesting2.la \
+  libgnunettransportapplication.la \
+  libgnunettransportcore.la \
+  $(top_builddir)/src/lib/testing/libgnunettesting.la \
+  $(top_builddir)/src/service/peerstore/libgnunetpeerstore.la \
+  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(top_builddir)/src/lib/hello/libgnunethello.la \
+  $(top_builddir)/src/service/arm/libgnunetarm.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunet_test_transport_plugin_cmd_simple_send_la_LDFLAGS = \
+  $(GN_PLUGIN_LDFLAGS)
+
+libgnunet_test_transport_plugin_cmd_simple_send_performance_la_SOURCES = \
+ test_transport_plugin_cmd_simple_send_performance.c
+libgnunet_test_transport_plugin_cmd_simple_send_performance_la_LIBADD = \
+  libgnunettransporttesting2.la \
+  libgnunettransportapplication.la \
+  libgnunettransportcore.la \
+  $(top_builddir)/src/lib/testing/libgnunettesting.la \
+  $(top_builddir)/src/service/peerstore/libgnunetpeerstore.la \
+  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(top_builddir)/src/lib/hello/libgnunethello.la \
+  $(top_builddir)/src/service/arm/libgnunetarm.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunet_test_transport_plugin_cmd_simple_send_performance_la_LDFLAGS = \
+  $(GN_PLUGIN_LDFLAGS)
+
+libgnunet_test_transport_plugin_cmd_simple_send_broadcast_la_SOURCES = \
+ test_transport_plugin_cmd_simple_send_broadcast.c
+libgnunet_test_transport_plugin_cmd_simple_send_broadcast_la_LIBADD = \
+  libgnunettransporttesting2.la \
+  libgnunettransportapplication.la \
+  libgnunettransportcore.la \
+  $(top_builddir)/src/lib/testing/libgnunettesting.la \
+  $(top_builddir)/src/service/peerstore/libgnunetpeerstore.la \
+  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(top_builddir)/src/lib/hello/libgnunethello.la \
+  $(top_builddir)/src/service/arm/libgnunetarm.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunet_test_transport_plugin_cmd_simple_send_broadcast_la_LDFLAGS = \
+  $(GN_PLUGIN_LDFLAGS)
+
+libgnunet_test_transport_plugin_cmd_simple_send_dv_la_SOURCES = \
+ test_transport_plugin_cmd_simple_send_dv.c
+libgnunet_test_transport_plugin_cmd_simple_send_dv_la_LIBADD = \
+  libgnunettransporttesting2.la \
+  libgnunettransportapplication.la \
+  libgnunettransportcore.la \
+  $(top_builddir)/src/lib/testing/libgnunettesting.la \
+  $(top_builddir)/src/service/peerstore/libgnunetpeerstore.la \
+  $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(top_builddir)/src/lib/hello/libgnunethello.la \
+  $(top_builddir)/src/service/arm/libgnunetarm.la \
+  $(top_builddir)/src/lib/util/libgnunetutil.la \
+  $(LTLIBINTL)
+libgnunet_test_transport_plugin_cmd_simple_send_dv_la_LDFLAGS = \
+  $(GN_PLUGIN_LDFLAGS)
+
+#check_PROGRAMS = \
+# test_communicator_basic-tcp \
+# test_communicator_basic-udp \
+# test_communicator_rekey-tcp \
+# test_communicator_bidirect-tcp \
+# test_communicator_rekey-udp \
+# test_communicator_backchannel-udp
+
+if HAVE_EXPERIMENTAL
+#check_PROGRAMS += test_communicator_basic-quic \
+# test_communicator_basic-unix
+check_SCRIPTS= \
+  test_transport_start_testcase.sh \
+  test_transport_simple_send_performance.sh \
+  test_transport_nat_icmp_tcp.sh \
+  test_transport_nat_upnp.sh \
+  test_transport_simple_send_string.sh \
+  test_transport_simple_send.sh \
+  test_transport_simple_send_broadcast.sh \
+  test_transport_udp_backchannel.sh \
+  test_transport_simple_send_dv_circle.sh \
+  test_transport_simple_send_dv_inverse.sh
+endif
+
+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_communicator_basic_unix_SOURCES = \
+ test_communicator_basic.c
+test_communicator_basic_unix_LDADD = \
+ libgnunettransporttesting2.la \
+ $(top_builddir)/src/lib/testing/libgnunettesting.la \
+ $(top_builddir)/src/lib/util/libgnunetutil.la \
+ $(top_builddir)/src/service/statistics/libgnunetstatistics.la
+
+test_communicator_basic_tcp_SOURCES = \
+ test_communicator_basic.c
+test_communicator_basic_tcp_LDADD = \
+ libgnunettransporttesting2.la \
+ $(top_builddir)/src/lib/testing/libgnunettesting.la \
+ $(top_builddir)/src/lib/util/libgnunetutil.la \
+ $(top_builddir)/src/service/statistics/libgnunetstatistics.la
+
+test_communicator_basic_udp_SOURCES = \
+ test_communicator_basic.c
+test_communicator_basic_udp_LDADD = \
+ libgnunettransporttesting2.la \
+ $(top_builddir)/src/lib/testing/libgnunettesting.la \
+ $(top_builddir)/src/lib/util/libgnunetutil.la \
+ $(top_builddir)/src/service/statistics/libgnunetstatistics.la
+
+test_communicator_basic_quic_SOURCES = \
+ test_communicator_basic.c
+test_communicator_basic_quic_LDADD = \
+ libgnunettransporttesting2.la \
+ $(top_builddir)/src/lib/testing/libgnunettesting.la \
+ $(top_builddir)/src/lib/util/libgnunetutil.la \
+ $(top_builddir)/src/service/statistics/libgnunetstatistics.la
+
+test_communicator_rekey_tcp_SOURCES = \
+ test_communicator_basic.c
+test_communicator_rekey_tcp_LDADD = \
+ libgnunettransporttesting2.la \
+ $(top_builddir)/src/lib/testing/libgnunettesting.la \
+ $(top_builddir)/src/lib/util/libgnunetutil.la \
+ $(top_builddir)/src/service/statistics/libgnunetstatistics.la
+
+test_communicator_rekey_udp_SOURCES = \
+ test_communicator_basic.c
+test_communicator_rekey_udp_LDADD = \
+ libgnunettransporttesting2.la \
+ $(top_builddir)/src/lib/testing/libgnunettesting.la \
+ $(top_builddir)/src/lib/util/libgnunetutil.la \
+ $(top_builddir)/src/service/statistics/libgnunetstatistics.la
+
+test_communicator_backchannel_udp_SOURCES = \
+ test_communicator_basic.c
+test_communicator_backchannel_udp_LDADD = \
+ libgnunettransporttesting2.la \
+ $(top_builddir)/src/lib/testing/libgnunettesting.la \
+ $(top_builddir)/src/lib/util/libgnunetutil.la \
+ $(top_builddir)/src/service/statistics/libgnunetstatistics.la
+
+test_communicator_bidirect_tcp_SOURCES = \
+ test_communicator_basic.c
+test_communicator_bidirect_tcp_LDADD = \
+ libgnunettransporttesting2.la \
+ $(top_builddir)/src/lib/testing/libgnunettesting.la \
+ $(top_builddir)/src/lib/util/libgnunetutil.la \
+ $(top_builddir)/src/service/statistics/libgnunetstatistics.la
+
+test_transport_api2_tcp_SOURCES = \
+ test_transport_api2.c
+test_transport_api2_tcp_LDADD = \
+ $(top_builddir)/src/lib/hello/libgnunethello.la \
+ $(top_builddir)/src/lib/util/libgnunetutil.la  \
+ libgnunettransporttesting2.la
+
+EXTRA_DIST = \
+test_transport_start_testcase.sh \
+test_transport_simple_send_performance.sh \
+test_transport_nat_icmp_tcp.sh \
+test_transport_nat_upnp.sh \
+test_transport_simple_send_string.sh \
+test_transport_simple_send.sh \
+test_transport_simple_send_broadcast.sh \
+test_transport_udp_backchannel.sh \
+test_transport_simple_send_dv_circle.sh \
+test_transport_simple_send_dv_inverse.sh \
+gnunet-transport-certificate-creation.in \
+test_plugin_hostkey \
+test_plugin_hostkey.ecc \
+test_delay \
+template_cfg_peer1.conf\
+template_cfg_peer2.conf\
+test_transport_api_data.conf\
+test_transport_api_multi_peer1.conf\
+test_transport_api_multi_peer2.conf\
+test_transport_api_tcp_nat_peer1.conf\
+test_transport_api_tcp_nat_peer2.conf\
+test_transport_api_tcp_peer1.conf\
+test_transport_api_tcp_peer2.conf\
+test_transport_api2_tcp_peer1.conf\
+test_transport_api2_tcp_peer2.conf\
+test_transport_api_udp_nat_peer1.conf\
+test_transport_api_udp_nat_peer2.conf\
+test_transport_api_udp_peer1.conf\
+test_transport_api_udp_peer2.conf\
+test_transport_api_unix_peer1.conf\
+test_transport_api_unix_peer2.conf\
+test_transport_api_monitor_peers_peer1.conf\
+test_transport_api_monitor_peers_peer2.conf\
+test_transport_api_monitor_validation_peer1.conf\
+test_transport_api_monitor_validation_peer2.conf\
+test_transport_defaults.conf\
+test_communicator_unix_basic_peer1.conf \
+test_communicator_unix_basic_peer2.conf \
+test_communicator_tcp_basic_peer1.conf \
+test_communicator_tcp_basic_peer2.conf \
+test_communicator_udp_basic_peer1.conf \
+test_communicator_udp_basic_peer2.conf \
+test_communicator_tcp_rekey_peer1.conf \
+test_communicator_tcp_rekey_peer2.conf \
+test_communicator_udp_rekey_peer1.conf \
+test_communicator_udp_rekey_peer2.conf \
+test_communicator_udp_backchannel_peer1.conf \
+test_communicator_udp_backchannel_peer2.conf \
+test_communicator_tcp_bidirect_peer1.conf \
+test_communicator_tcp_bidirect_peer2.conf
diff --git a/src/service/transport/NOTES b/src/service/transport/NOTES
new file mode 100644
index 000000000..41404e1f9
--- /dev/null
+++ b/src/service/transport/NOTES
@@ -0,0 +1,46 @@
+KEY DESIGN CHOICES:
+ - who decides which connections to keep/create?
+   => higher level session/key management!
+ - who enforces things like F2F topology, etc?
+   => higher level session/key management!
+ - who tracks all known HELLOs & validates? 
+   => We validate, PEERINFO tracks!
+ - who advertises our HELLO?
+   => us! (need background job; previously: advertising)
+ - who advertises other peers HELLOs?
+   => higher level (core?)
+ - who does bootstrapping?
+   => bootstrap service (external!)
+ - who enforces inbound bandwidth limits?
+   => transport-service and plugins! (previously: core); 
+      either by limiting reads (TCP) or discarding packets 
+      (transport-service)
+ - who enforces outbound bandwidth limits?
+   => transport_api!
+ - who decides outbound bandwidth limits?
+   => other peer, via core (need authenticated limits!)
+ - who decides inbound bandwidth limits?
+   => core / apps above core (need trust info)
+ - cost function for transports is latency estimate in ms
+   => plugin provides latency data, transport-service
+      selects plugin(s) for transmission
+ - who is responsible for fragmentation?
+   => plugins! (may use common shared library)
+ - should we require UDP to be reliable?
+   => NO.  There are other places that may (rarely)
+      use messages that we can not fix
+ - how do we access the 50% of service that we need for TCP/UDP
+   from service.c without code replication or getting 50%
+   that we do not want (i.e. shutdown, pid-file-writing, etc.)
+   => use GNUNET_SERVICE_start/stop functions!
+ - At what level do we manage timeouts? 
+   => At the plugin (TCP connections),
+      transport-service (neighbours) and 
+      core (sessions) level!
+   => All plugins have to disconnect before service-level
+      disconnect occurs
+   => We can have a plugin-connection die, but the session
+      survives!
+   => We can have a session die (no further authenticated
+      communication) even if the plugin thinks it is still
+      up!
diff --git a/src/service/transport/benchmark.sh b/src/service/transport/benchmark.sh
new file mode 100755
index 000000000..a29e6ec2d
--- /dev/null
+++ b/src/service/transport/benchmark.sh
@@ -0,0 +1,13 @@
+#!/bin/sh
+
+for i in $(seq 1 0)
+do
+ echo RUN $i
+ ./test_transport_api_reliability_http
+done
+
+for i in $(seq 1 100)
+do
+ echo RUN $i
+ ./test_transport_api_reliability_https
+done
diff --git a/src/service/transport/communicator.h b/src/service/transport/communicator.h
new file mode 100644
index 000000000..5ef43597d
--- /dev/null
+++ b/src/service/transport/communicator.h
@@ -0,0 +1,138 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009-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 transport/communicator.h
+ * @brief common internal definitions for communicator services
+ * @author Christian Grothoff
+ */
+#ifndef COMMUNICATOR_H
+#define COMMUNICAOTR_H
+
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * Message used to tell a communicator about a successful
+ * key exchange.
+ *
+ * Note that this style of KX acknowledgement typically only applies
+ * for communicators where the underlying network protocol is
+ * unidirectional and/or lacks cryptography.  Furthermore, this is
+ * just the recommended "generic" style, communicators are always free
+ * to implement original designs that better fit their requirements.
+ */
+struct GNUNET_TRANSPORT_CommunicatorGenericKXConfirmation
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_KX_CONFIRMATION
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Timestamp from the original sender which identifies the original KX.
+   */
+  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
+
+  /**
+   * How long does the receiver of the KX believe that the address
+   * on which the KX was received will continue to be valid.
+   */
+  struct GNUNET_TIME_RelativeNBO validity;
+
+  /**
+   * Hash of the shared secret. Specific hash function may depend on
+   * the communicator's protocol details.
+   */
+  struct GNUNET_HashCode token;
+};
+
+
+/**
+ * Message used to tell a communicator about the receiver's
+ * flow control limits and to acknowledge receipt of certain
+ * messages.
+ *
+ * Note that a sender MAY choose to violate the flow-control
+ * limits provided in this message by a receiver, which may
+ * result in messages being lost (after all, transport is an
+ * unreliable channel).  So if the sender violates these
+ * constraints, it should expect that the receive will simply
+ * discard the (partially) received "old" messages.
+ *
+ * This way, if a sender or receiver crashes, there is no protocol
+ * violation.
+ *
+ * Note that this style of flow control typically only applies
+ * for communicators where the underlying network protocol does
+ * not already implement flow control.  Furthermore, this is
+ * just the recommended "generic" style, communicators are always
+ * free to implement original designs that better fit their
+ * requirements.
+ */
+struct GNUNET_TRANSPORT_CommunicatorGenericFCLimits
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_FC_LIMITS
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Maximum number of messages beyond the acknowledged message
+   * number that can still be transmitted concurrently without
+   * further acknowledgements.
+   */
+  uint32_t msg_window_size;
+
+  /**
+   * Up to which message number were all messages received.
+   */
+  uint64_t msg_cummulative_ack;
+
+  /**
+   * Maximum number of payload bytes beyond the acknowledged
+   * number of bytes can still be transmitted without further
+   * acknowledgements.
+   */
+  uint64_t bytes_window_size;
+
+  /**
+   * Cumulative acknowledgement for number of bytes received.
+   */
+  uint64_t bytes_cummulative_ack;
+
+  /**
+   * Followed by a variable-size bitfield for messages received
+   * beyond @e msg_cummulative_ack. Index at offset 0 must thus
+   * be zero, otherwise @e msg_cummulative_ack should be
+   * increased.  Note that this field can be overall of 0 bytes.
+   * The variable-size bitfield must be a multiple of 64 bits
+   * long.
+   */
+  /* uint64_t msg_selective_ack_field[]; */
+};
+
+
+GNUNET_NETWORK_STRUCT_END
+
+/* end of communicator.h */
+#endif
diff --git a/src/service/transport/gnunet-communicator-quic.c b/src/service/transport/gnunet-communicator-quic.c
new file mode 100644
index 000000000..0a7e511eb
--- /dev/null
+++ b/src/service/transport/gnunet-communicator-quic.c
@@ -0,0 +1,1795 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2010-2014, 2018, 2019 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 transport/gnunet-communicator-quic.c
+ * @brief Transport plugin using QUIC.
+ * @author Marshall Stone
+ * @author Martin Schanzenbach
+ *
+ * TODO:
+ * - Automatically generate self-signed x509 certificates and load from config
+ * - Figure out MTU and how we have to handle fragmentation in Quiche.
+ * - Mandate timeouts
+ * - Setup stats handler properly
+ * - Doxygen documentation of methods
+ * - Refactor code shared with UDP and TCP communicator
+ * - Performance testing
+ * - Check for memory leaks with coverity/valgrind
+ */
+#include "gnunet_common.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_core_service.h"
+#include "quiche.h"
+#include "platform.h"
+#include "gnunet_protocols.h"
+#include "gnunet_signatures.h"
+#include "gnunet_constants.h"
+#include "gnunet_statistics_service.h"
+#include "gnunet_transport_application_service.h"
+#include "gnunet_transport_communication_service.h"
+#include "gnunet_nat_service.h"
+#include "stdint.h"
+#include "inttypes.h"
+
+#define COMMUNICATOR_CONFIG_SECTION "communicator-quic"
+#define COMMUNICATOR_ADDRESS_PREFIX "quic"
+#define MAX_DATAGRAM_SIZE 1350
+
+
+/* FIXME: Review all static lengths/contents below. Maybe this can be done smarter */
+/* Currently equivalent to QUICHE_MAX_CONN_ID_LEN */
+#define LOCAL_CONN_ID_LEN 20
+#define MAX_TOKEN_LEN \
+        sizeof("quiche") - 1   \
+        + sizeof(struct sockaddr_storage)   \
+        + QUICHE_MAX_CONN_ID_LEN
+#define CID_LEN sizeof(uint8_t) * QUICHE_MAX_CONN_ID_LEN
+#define TOKEN_LEN sizeof (uint8_t) * MAX_TOKEN_LEN
+
+
+/* FIXME: Why 4?
+   Generic, bidirectional, client-initiated quic stream id */
+#define STREAMID_BI 4
+
+/**
+ * How long do we believe our addresses to remain up (before
+ * the other peer should revalidate).
+ */
+#define ADDRESS_VALIDITY_PERIOD GNUNET_TIME_UNIT_HOURS
+
+/**
+ * Map of DCID (uint8_t) -> quic_conn for quickly retrieving connections to other peers.
+ */
+struct GNUNET_CONTAINER_MultiHashMap *conn_map;
+
+/**
+ * Map of sockaddr -> struct PeerAddress
+ */
+struct GNUNET_CONTAINER_MultiHashMap *addr_map;
+
+/**
+ * Handle to the config
+ */
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * FIXME undocumented
+ */
+static struct GNUNET_TIME_Relative rekey_interval;
+
+/**
+ * FIXME undocumented
+ */
+static struct GNUNET_NETWORK_Handle *udp_sock;
+
+/**
+ * FIXME undocumented
+ */
+static struct GNUNET_SCHEDULER_Task *read_task;
+
+/**
+ * FIXME undocumented
+ */
+static struct GNUNET_TRANSPORT_CommunicatorHandle *ch;
+
+/**
+ * FIXME undocumented
+ */
+static struct GNUNET_TRANSPORT_ApplicationHandle *ah;
+
+/**
+ * FIXME undocumented
+ */
+static int have_v6_socket;
+
+/**
+ * FIXME undocumented
+ */
+static uint16_t my_port;
+
+/**
+ * FIXME undocumented
+ */
+static unsigned long long rekey_max_bytes;
+
+/**
+ * FIXME undocumented
+ */
+static quiche_config *config = NULL;
+
+/**
+ * Our peer identity
+*/
+struct GNUNET_PeerIdentity my_identity;
+
+/**
+ * Our private key.
+ */
+static struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
+
+/**
+ * Connection to NAT service.
+ */
+static struct GNUNET_NAT_Handle *nat;
+
+/**
+ * Information we track per peer we have recently been in contact with.
+ *
+ * (Since quiche handles crypto, handshakes, etc. we don't differentiate
+ *  between SenderAddress and ReceiverAddress)
+ * FIXME: But we do a handshake as well. The flag in this struct seems to
+ * indicate this. Update comment!
+ */
+struct PeerAddress
+{
+  /**
+   * To whom are we talking to.
+   */
+  struct GNUNET_PeerIdentity target;
+
+  /**
+   * Flag to indicate whether we know the PeerIdentity (target) yet
+  */
+  int id_rcvd;
+
+  /**
+   * Flag to indicate whether we have sent OUR PeerIdentity to this peer
+  */
+  int id_sent;
+
+  /**
+   * Flag to indicate if we are the initiator of the connection
+  */
+  int is_receiver;
+
+  /**
+   * Address of the receiver in the human-readable format
+   * with the #COMMUNICATOR_ADDRESS_PREFIX.
+   */
+  char *foreign_addr;
+
+  /**
+   * Address of the other peer.
+   */
+  struct sockaddr *address;
+
+  /**
+   * Length of the address.
+   */
+  socklen_t address_len;
+
+  /**
+   * The QUIC connection associated with this peer
+  */
+  struct quic_conn *conn;
+
+  /**
+   * Default message queue we are providing for the #ch.
+   */
+  struct GNUNET_MQ_Handle *d_mq;
+
+  /**
+   * handle for default queue with the #ch.
+   */
+  struct GNUNET_TRANSPORT_QueueHandle *d_qh;
+
+  /**
+   * Timeout for this peer address.
+   */
+  struct GNUNET_TIME_Absolute timeout;
+
+  /**
+   * MTU we allowed transport for this peer's default queue.
+   * FIXME: MTU from quiche
+   */
+  size_t d_mtu;
+
+  /**
+   * Which network type does this queue use?
+   */
+  enum GNUNET_NetworkType nt;
+
+  /**
+   * receiver_destroy already called on receiver.
+   */
+  int peer_destroy_called;
+
+  /**
+   * FIXME implementation missing
+   * Entry in sender expiration heap.
+   */
+  // struct GNUNET_CONTAINER_HeapNode *hn;
+};
+
+// /**
+//  * FIXME: Implementation missing
+//  * Expiration heap for peers (contains `struct PeerAddress`)
+//  */
+// static struct GNUNET_CONTAINER_Heap *peers_heap;
+
+/**
+ * ID of timeout task
+ */
+static struct GNUNET_SCHEDULER_Task *timeout_task;
+
+/**
+ * Network scanner to determine network types.
+ */
+static struct GNUNET_NT_InterfaceScanner *is;
+
+/**
+ * For logging statistics.
+ */
+static struct GNUNET_STATISTICS_Handle *stats;
+
+/**
+ * QUIC connection object. A connection has a unique SCID/DCID pair. Here we store our SCID
+ * (incoming packet DCID field == outgoing packet SCID field) for a given connection. This
+ * is hashed for each unique quic_conn.
+*/
+struct quic_conn
+{
+  uint8_t cid[LOCAL_CONN_ID_LEN];
+
+  quiche_conn *conn;
+};
+
+/**
+ * QUIC_header is used to store information received from an incoming QUIC packet
+*/
+struct QUIC_header
+{
+  uint8_t type;
+  uint32_t version;
+
+  uint8_t scid[QUICHE_MAX_CONN_ID_LEN];
+  size_t scid_len;
+
+  uint8_t dcid[QUICHE_MAX_CONN_ID_LEN];
+  size_t dcid_len;
+
+  uint8_t odcid[QUICHE_MAX_CONN_ID_LEN];
+  size_t odcid_len;
+
+  uint8_t token[MAX_TOKEN_LEN];
+  size_t token_len;
+};
+
+
+/**
+ * Given a PeerAddress, receive data from streams after doing connection logic.
+ * ASSUMES: connection is established to peer
+*/
+static void
+recv_from_streams (struct PeerAddress *peer)
+{
+  char stream_buf[UINT16_MAX];
+  size_t buf_size = UINT16_MAX;
+  char *buf_ptr = stream_buf;
+  struct GNUNET_MessageHeader *hdr;
+
+  uint64_t s = 0;
+  quiche_stream_iter *readable;
+  bool fin;
+  ssize_t recv_len;
+
+  readable = quiche_conn_readable (peer->conn->conn);
+  while (quiche_stream_iter_next (readable, &s))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,  "stream %" PRIu64 " is readable\n",
+                s);
+    fin = false;
+    recv_len = quiche_conn_stream_recv (peer->conn->conn, s,
+                                        (uint8_t *) stream_buf, buf_size,
+                                        &fin);
+    if (recv_len < 0)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "error while receiving data from stream %" PRIu64 "\n", s);
+      break;
+    }
+    /**
+     * FIXME: Do not use implicit booleans. Use GNUNET_YES, GNUNET_NO, GNUNET_SYSERR
+     * and check for that.
+     *
+     * Initial packet should contain peerid if they are the initiator
+     */
+    if (! peer->is_receiver && GNUNET_NO == peer->id_rcvd)
+    {
+      if (recv_len < sizeof(struct GNUNET_PeerIdentity))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "message recv len of %zd less than length of peer identity\n",
+                    recv_len);
+        return;
+      }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "received peer identity\n");
+      struct GNUNET_PeerIdentity *pid = (struct
+                                         GNUNET_PeerIdentity *) stream_buf;
+      peer->target = *pid;
+      peer->id_rcvd = GNUNET_YES;
+      buf_ptr += sizeof(struct GNUNET_PeerIdentity);
+      recv_len -= sizeof(struct GNUNET_PeerIdentity);
+    }
+    /**
+     * Parse messages to pass to communicator
+    */
+    while (recv_len >= sizeof(struct GNUNET_MessageHeader))
+    {
+      hdr = (struct GNUNET_MessageHeader *) buf_ptr;
+      if (ntohs (hdr->size) > recv_len)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "message size stated (%d) is greater than length of rcvd data (%zd)!\n",
+                    ntohs (hdr->size), recv_len);
+        return;
+      }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "passing %zd bytes to core\n",
+                  recv_len);
+      GNUNET_TRANSPORT_communicator_receive (ch, &peer->target, hdr,
+                                             ADDRESS_VALIDITY_PERIOD, NULL,
+                                             NULL);
+      recv_len -= ntohs (hdr->size);
+      buf_ptr += ntohs (hdr->size);
+    }
+    /**
+     * Check for leftover bytes
+    */
+    if (0 != recv_len)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "message recv len of %zd less than length of message header\n",
+                  recv_len);
+    }
+    /**
+     * FIXME: comment useless
+     * fin
+     */
+    if (fin)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "fin received, closing connection\n");
+      if (0 > quiche_conn_close (peer->conn->conn, true, 0, NULL, 0))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "quiche failed to close connection to peer\n");
+      }
+    }
+  }
+  quiche_stream_iter_free (readable);
+}
+
+
+/**
+ * FIXME: review token generation, assure tokens are generated properly. doxygen
+ */
+static void
+mint_token (const uint8_t *dcid, size_t dcid_len,
+            struct sockaddr_storage *addr, socklen_t addr_len,
+            uint8_t *token, size_t *token_len)
+{
+  GNUNET_memcpy (token, "quiche", sizeof("quiche") - 1);
+  GNUNET_memcpy (token + sizeof("quiche") - 1, addr, addr_len);
+  GNUNET_memcpy (token + sizeof("quiche") - 1 + addr_len, dcid, dcid_len);
+
+  *token_len = sizeof("quiche") - 1 + addr_len + dcid_len;
+}
+
+
+static enum GNUNET_GenericReturnValue
+validate_token (const uint8_t *token, size_t token_len,
+                struct sockaddr_storage *addr, socklen_t addr_len,
+                uint8_t *odcid, size_t *odcid_len)
+{
+  if ((token_len < sizeof("quiche") - 1) ||
+      memcmp (token, "quiche", sizeof("quiche") - 1))
+  {
+    return GNUNET_NO;
+  }
+
+  token += sizeof("quiche") - 1;
+  token_len -= sizeof("quiche") - 1;
+
+  if ((token_len < addr_len) || memcmp (token, addr, addr_len))
+  {
+    return GNUNET_NO;
+  }
+
+  token += addr_len;
+  token_len -= addr_len;
+
+  if (*odcid_len < token_len)
+  {
+    return GNUNET_NO;
+  }
+
+  memcpy (odcid, token, token_len);
+  *odcid_len = token_len;
+
+  return GNUNET_OK;
+}
+
+
+static struct quic_conn*
+create_conn (uint8_t *scid, size_t scid_len,
+             uint8_t *odcid, size_t odcid_len,
+             struct sockaddr *local_addr,
+             socklen_t local_addr_len,
+             struct sockaddr_storage *peer_addr,
+             socklen_t peer_addr_len)
+{
+  struct quic_conn *conn;
+  quiche_conn *q_conn;
+  conn = GNUNET_new (struct quic_conn);
+  if (scid_len != LOCAL_CONN_ID_LEN)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "error while creating connection, scid length too short: %zu\n",
+                scid_len);
+    return NULL;
+  }
+
+  GNUNET_memcpy (conn->cid, scid, LOCAL_CONN_ID_LEN);
+  q_conn = quiche_accept (conn->cid, LOCAL_CONN_ID_LEN,
+                          odcid, odcid_len,
+                          local_addr,
+                          local_addr_len,
+                          (struct sockaddr *) peer_addr,
+                          peer_addr_len,
+                          config);
+  if (NULL == q_conn)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "quiche failed to create connection after call to quiche_accept\n");
+    return NULL;
+  }
+  conn->conn = q_conn;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "new quic connection created\n");
+  return conn;
+}
+
+
+static void
+flush_egress (struct quic_conn *conn)
+{
+  static uint8_t out[MAX_DATAGRAM_SIZE];
+  quiche_send_info send_info;
+
+  ssize_t written;
+  ssize_t sent;
+
+  while (1)
+  {
+    written = quiche_conn_send (conn->conn, out, sizeof(out), &send_info);
+    if (QUICHE_ERR_DONE == written)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "done writing quic packets\n");
+      break;
+    }
+    if (0 > written)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "quiche failed to create packet. quiche error: %zd\n",
+                  written);
+      return;
+    }
+    sent = GNUNET_NETWORK_socket_sendto (udp_sock, out, written,
+                                         (struct sockaddr *) &send_info.to,
+                                         send_info.to_len);
+    if (sent != written)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "quiche failed to send data to peer\n");
+      return;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "sent %zd bytes\n", sent);
+  }
+}
+
+
+/**
+ * Increment receiver timeout due to activity.
+ *
+ * @param receiver address for which the timeout should be rescheduled
+ */
+static void
+reschedule_peer_timeout (struct PeerAddress *peer)
+{
+  peer->timeout =
+    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+  // GNUNET_CONTAINER_heap_update_cost (peer->hn,
+  //                                    peer->timeout.abs_value_us);
+}
+
+
+/**
+ * Destroys a receiving state due to timeout or shutdown.
+ *
+ * @param receiver entity to close down
+ */
+static void
+peer_destroy (struct PeerAddress *peer)
+{
+  struct GNUNET_HashCode addr_key;
+
+  peer->peer_destroy_called = GNUNET_YES;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Disconnecting peer for peer `%s'\n",
+              GNUNET_i2s (&peer->target));
+  if (NULL != peer->d_qh)
+  {
+    GNUNET_TRANSPORT_communicator_mq_del (peer->d_qh);
+    peer->d_qh = NULL;
+  }
+  // GNUNET_assert (peer == GNUNET_CONTAINER_heap_remove_node (peer->hn));
+  /**
+   * Remove peer from hashmap
+  */
+  GNUNET_CRYPTO_hash (peer->address, peer->address_len, &addr_key);
+  if (GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove (addr_map, &addr_key,
+                                                         peer))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "tried to remove non-existent peer from addr map\n");
+    return;
+  }
+  GNUNET_STATISTICS_set (stats,
+                         "# peers active",
+                         GNUNET_CONTAINER_multihashmap_size (addr_map),
+                         GNUNET_NO);
+  quiche_conn_free (peer->conn->conn);
+  GNUNET_free (peer->address);
+  GNUNET_free (peer->foreign_addr);
+  GNUNET_free (peer->conn);
+  GNUNET_free (peer);
+}
+
+
+/**
+ * Iterator over all peers to clean up.
+ *
+ * @param cls NULL
+ * @param key peer->address
+ * @param value the peer to destroy
+ * @return #GNUNET_OK to continue to iterate
+ */
+static int
+get_peer_delete_it (void *cls,
+                    const struct GNUNET_HashCode *key,
+                    void *value)
+{
+  struct PeerAddress *peer = value;
+  (void) cls;
+  (void) key;
+  peer_destroy (peer);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Signature of functions implementing the sending functionality of a
+ * message queue.
+ *
+ * @param mq the message queue
+ * @param msg the message to send
+ * @param impl_state our `struct PeerAddress`
+ */
+static void
+mq_send_d (struct GNUNET_MQ_Handle *mq,
+           const struct GNUNET_MessageHeader *msg,
+           void *impl_state)
+{
+  struct PeerAddress *peer = impl_state;
+  uint16_t msize = ntohs (msg->size);
+  ssize_t send_len;
+
+  if (NULL == peer->conn->conn)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "peer never established quic connection\n");
+    return;
+  }
+
+  GNUNET_assert (mq == peer->d_mq);
+  if (msize > peer->d_mtu)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "msize: %u, mtu: %lu\n",
+                msize,
+                peer->d_mtu);
+    GNUNET_break (0);
+    if (GNUNET_YES != peer->peer_destroy_called)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "peer destroy called, destroying peer\n");
+      peer_destroy (peer);
+    }
+    return;
+  }
+  reschedule_peer_timeout (peer);
+
+  send_len = quiche_conn_stream_send (peer->conn->conn, 4, (uint8_t *) msg,
+                                      msize, false);
+  if (send_len != msize)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "tried to send message and quiche returned %zd", send_len);
+    return;
+  }
+  flush_egress (peer->conn);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "sent a message of %zd bytes\n", send_len);
+  GNUNET_MQ_impl_send_continue (mq);
+}
+
+
+/**
+ * Signature of functions implementing the destruction of a message
+ * queue.  Implementations must not free @a mq, but should take care
+ * of @a impl_state.
+ *
+ * @param mq the message queue to destroy
+ * @param impl_state our `struct PeerAddress`
+ */
+static void
+mq_destroy_d (struct GNUNET_MQ_Handle *mq, void *impl_state)
+{
+  struct PeerAddress *peer = impl_state;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Default MQ destroyed\n");
+  if (mq == peer->d_mq)
+  {
+    peer->d_mq = NULL;
+    if (GNUNET_YES != peer->peer_destroy_called)
+      peer_destroy (peer);
+  }
+}
+
+
+/**
+ * Implementation function that cancels the currently sent message.
+ *
+ * @param mq message queue
+ * @param impl_state our `struct PeerAddress`
+ */
+static void
+mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
+{
+  /* Cancellation is impossible with QUIC; bail */
+  GNUNET_assert (0);
+}
+
+
+/**
+ * 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 our `struct ReceiverAddress`
+ * @param error error code
+ */
+static void
+mq_error (void *cls, enum GNUNET_MQ_Error error)
+{
+  struct PeerAddress *peer = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "MQ error in queue to %s: %d\n",
+              GNUNET_i2s (&peer->target),
+              (int) error);
+  peer_destroy (peer);
+}
+
+
+/**
+ * Convert UDP bind specification to a `struct sockaddr *`
+ *
+ * @param bindto bind specification to convert
+ * @param[out] sock_len set to the length of the address
+ * @return converted bindto specification
+ */
+static struct sockaddr *
+udp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
+{
+  struct sockaddr *in;
+  unsigned int port;
+  char dummy[2];
+  char *colon;
+  char *cp;
+
+  if (1 == sscanf (bindto, "%u%1s", &port, dummy))
+  {
+    /* interpreting value as just a PORT number */
+    if (port > UINT16_MAX)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "BINDTO specification `%s' invalid: value too large for port\n",
+                  bindto);
+      return NULL;
+    }
+    if ((GNUNET_NO == GNUNET_NETWORK_test_pf (PF_INET6)) ||
+        (GNUNET_YES ==
+         GNUNET_CONFIGURATION_get_value_yesno (cfg,
+                                               COMMUNICATOR_CONFIG_SECTION,
+                                               "DISABLE_V6")))
+    {
+      struct sockaddr_in *i4;
+
+      i4 = GNUNET_malloc (sizeof(struct sockaddr_in));
+      i4->sin_family = AF_INET;
+      i4->sin_port = htons ((uint16_t) port);
+      *sock_len = sizeof(struct sockaddr_in);
+      in = (struct sockaddr *) i4;
+    }
+    else
+    {
+      struct sockaddr_in6 *i6;
+
+      i6 = GNUNET_malloc (sizeof(struct sockaddr_in6));
+      i6->sin6_family = AF_INET6;
+      i6->sin6_port = htons ((uint16_t) port);
+      *sock_len = sizeof(struct sockaddr_in6);
+      in = (struct sockaddr *) i6;
+    }
+    return in;
+  }
+  cp = GNUNET_strdup (bindto);
+  colon = strrchr (cp, ':');
+  if (NULL != colon)
+  {
+    /* interpret value after colon as port */
+    *colon = '\0';
+    colon++;
+    if (1 == sscanf (colon, "%u%1s", &port, dummy))
+    {
+      /* interpreting value as just a PORT number */
+      if (port > UINT16_MAX)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "BINDTO specification `%s' invalid: value too large for port\n",
+                    bindto);
+        GNUNET_free (cp);
+        return NULL;
+      }
+    }
+    else
+    {
+      GNUNET_log (
+        GNUNET_ERROR_TYPE_ERROR,
+        "BINDTO specification `%s' invalid: last ':' not followed by number\n",
+        bindto);
+      GNUNET_free (cp);
+      return NULL;
+    }
+  }
+  else
+  {
+    /* interpret missing port as 0, aka pick any free one */
+    port = 0;
+  }
+  {
+    /* try IPv4 */
+    struct sockaddr_in v4;
+
+    memset (&v4, 0, sizeof(v4));
+    if (1 == inet_pton (AF_INET, cp, &v4.sin_addr))
+    {
+      v4.sin_family = AF_INET;
+      v4.sin_port = htons ((uint16_t) port);
+#if HAVE_SOCKADDR_IN_SIN_LEN
+      v4.sin_len = sizeof(struct sockaddr_in);
+#endif
+      in = GNUNET_memdup (&v4, sizeof(struct sockaddr_in));
+      *sock_len = sizeof(struct sockaddr_in);
+      GNUNET_free (cp);
+      return in;
+    }
+  }
+  {
+    /* try IPv6 */
+    struct sockaddr_in6 v6;
+    const char *start;
+
+    memset (&v6, 0, sizeof(v6));
+    start = cp;
+    if (('[' == *cp) && (']' == cp[strlen (cp) - 1]))
+    {
+      start++;   /* skip over '[' */
+      cp[strlen (cp) - 1] = '\0';  /* eat ']' */
+    }
+    if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
+    {
+      v6.sin6_family = AF_INET6;
+      v6.sin6_port = htons ((uint16_t) port);
+#if HAVE_SOCKADDR_IN_SIN_LEN
+      v6.sin6_len = sizeof(sizeof(struct sockaddr_in6));
+#endif
+      in = GNUNET_memdup (&v6, sizeof(v6));
+      *sock_len = sizeof(v6);
+      GNUNET_free (cp);
+      return in;
+    }
+  }
+  /* #5528 FIXME (feature!): maybe also try getnameinfo()? */
+  GNUNET_free (cp);
+  return NULL;
+}
+
+
+/**
+ * Setup the MQ for the @a peer.  If a queue exists,
+ * the existing one is destroyed.  Then the MTU is
+ * recalculated and a fresh queue is initialized.
+ *
+ * @param peer peer to setup MQ for
+ */
+static void
+setup_peer_mq (struct PeerAddress *peer)
+{
+  size_t base_mtu;
+
+  switch (peer->address->sa_family)
+  {
+  case AF_INET:
+    base_mtu = 1480     /* Ethernet MTU, 1500 - Ethernet header - VLAN tag */
+               - sizeof(struct GNUNET_TUN_IPv4Header) /* 20 */
+               - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */;
+    break;
+
+  case AF_INET6:
+    base_mtu = 1280     /* Minimum MTU required by IPv6 */
+               - sizeof(struct GNUNET_TUN_IPv6Header) /* 40 */
+               - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */;
+    break;
+
+  default:
+    GNUNET_assert (0);
+    break;
+  }
+  /* MTU == base_mtu */
+  peer->d_mtu = base_mtu;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Setting up MQs and QHs\n");
+  /* => Effective MTU for CORE will range from 1080 (IPv6 + KX) to
+     1404 (IPv4 + Box) bytes, depending on circumstances... */
+
+  if (NULL == peer->d_mq)
+    peer->d_mq = GNUNET_MQ_queue_for_callbacks (&mq_send_d,
+                                                &mq_destroy_d,
+                                                &mq_cancel,
+                                                peer,
+                                                NULL,
+                                                &mq_error,
+                                                peer);
+  peer->d_qh =
+    GNUNET_TRANSPORT_communicator_mq_add (ch,
+                                          &peer->target,
+                                          peer->foreign_addr,
+                                          1000,
+                                          GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED,
+                                          0, /* Priority */
+                                          peer->nt,
+                                          GNUNET_TRANSPORT_CS_OUTBOUND,
+                                          peer->d_mq);
+}
+
+
+/**
+ * Taken from: UDP communicator
+ * Converts @a address to the address string format used by this
+ * communicator in HELLOs.
+ *
+ * @param address the address to convert, must be AF_INET or AF_INET6.
+ * @param address_len number of bytes in @a address
+ * @return string representation of @a address
+ */
+static char *
+sockaddr_to_udpaddr_string (const struct sockaddr *address,
+                            socklen_t address_len)
+{
+  char *ret;
+
+  switch (address->sa_family)
+  {
+  case AF_INET:
+    GNUNET_asprintf (&ret,
+                     "%s-%s",
+                     COMMUNICATOR_ADDRESS_PREFIX,
+                     GNUNET_a2s (address, address_len));
+    break;
+
+  case AF_INET6:
+    GNUNET_asprintf (&ret,
+                     "%s-%s",
+                     COMMUNICATOR_ADDRESS_PREFIX,
+                     GNUNET_a2s (address, address_len));
+    break;
+
+  default:
+    GNUNET_assert (0);
+  }
+  return ret;
+}
+
+
+/**
+ * Function called when the transport service has received a
+ * backchannel message for this communicator (!) via a different return
+ * path. Should be an acknowledgement.
+ *
+ * @param cls closure, NULL
+ * @param sender which peer sent the notification
+ * @param msg payload
+ */
+static void
+notify_cb (void *cls,
+           const struct GNUNET_PeerIdentity *sender,
+           const struct GNUNET_MessageHeader *msg)
+{
+  // const struct UDPAck *ack;
+
+  // (void) cls;
+  // GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+  //             "Storing UDPAck received from backchannel from %s\n",
+  //             GNUNET_i2s_full (sender));
+  // if ((ntohs (msg->type) != GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK) ||
+  //     (ntohs (msg->size) != sizeof(struct UDPAck)))
+  // {
+  //   GNUNET_break_op (0);
+  //   return;
+  // }
+  // ack = (const struct UDPAck *) msg;
+  // GNUNET_CONTAINER_multipeermap_get_multiple (receivers,
+  //                                             sender,
+  //                                             &handle_ack,
+  //                                             (void *) ack);
+}
+
+
+/**
+ * Task run to check #receiver_heap and #sender_heap for timeouts.
+ *
+ * @param cls unused, NULL
+ */
+static void
+check_timeouts (void *cls)
+{
+  // struct GNUNET_TIME_Relative st;
+  // struct GNUNET_TIME_Relative rt;
+  // struct GNUNET_TIME_Relative delay;
+  // struct ReceiverAddress *receiver;
+  // struct SenderAddress *sender;
+
+  // (void) cls;
+  // timeout_task = NULL;
+  // rt = GNUNET_TIME_UNIT_FOREVER_REL;
+  // while (NULL != (receiver = GNUNET_CONTAINER_heap_peek (receivers_heap)))
+  // {
+  //   /* if (GNUNET_YES != receiver->receiver_destroy_called) */
+  //   /* { */
+  //   rt = GNUNET_TIME_absolute_get_remaining (receiver->timeout);
+  //   if (0 != rt.rel_value_us)
+  //     break;
+  //   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+  //               "Receiver timed out\n");
+  //   receiver_destroy (receiver);
+  //   // }
+  // }
+  // st = GNUNET_TIME_UNIT_FOREVER_REL;
+  // while (NULL != (sender = GNUNET_CONTAINER_heap_peek (senders_heap)))
+  // {
+  //   if (GNUNET_YES != sender->sender_destroy_called)
+  //   {
+  //     st = GNUNET_TIME_absolute_get_remaining (sender->timeout);
+  //     if (0 != st.rel_value_us)
+  //       break;
+  //     sender_destroy (sender);
+  //   }
+  // }
+  // delay = GNUNET_TIME_relative_min (rt, st);
+  // if (delay.rel_value_us < GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
+  //   timeout_task = GNUNET_SCHEDULER_add_delayed (delay, &check_timeouts, NULL);
+}
+
+
+/**
+ * Function called by the transport service to initialize a
+ * message queue given address information about another peer.
+ * If and when the communication channel is established, the
+ * communicator must call #GNUNET_TRANSPORT_communicator_mq_add()
+ * to notify the service that the channel is now up.  It is
+ * the responsibility of the communicator to manage sane
+ * retries and timeouts for any @a peer/@a address combination
+ * provided by the transport service.  Timeouts and retries
+ * do not need to be signalled to the transport service.
+ *
+ * @param cls closure
+ * @param peer identity of the other peer
+ * @param address where to send the message, human-readable
+ *        communicator-specific format, 0-terminated, UTF-8
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if the provided address is
+ * invalid
+ */
+static int
+mq_init (void *cls, const struct GNUNET_PeerIdentity *peer_id, const
+         char *address)
+{
+  struct PeerAddress *peer;
+  const char *path;
+  struct sockaddr *in;
+  socklen_t in_len;
+  struct GNUNET_HashCode addr_key;
+  uint8_t scid[LOCAL_CONN_ID_LEN];
+
+  struct quic_conn *q_conn;
+  char *bindto;
+  socklen_t local_in_len;
+  struct sockaddr *local_addr;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             COMMUNICATOR_CONFIG_SECTION,
+                                             "BINDTO",
+                                             &bindto))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               COMMUNICATOR_CONFIG_SECTION,
+                               "BINDTO");
+    return GNUNET_SYSERR;
+  }
+  local_addr = udp_address_to_sockaddr (bindto, &local_in_len);
+
+  if (0 != strncmp (address,
+                    COMMUNICATOR_ADDRESS_PREFIX "-",
+                    strlen (COMMUNICATOR_ADDRESS_PREFIX "-")))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  path = &address[strlen (COMMUNICATOR_ADDRESS_PREFIX "-")];
+  in = udp_address_to_sockaddr (path, &in_len);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mq_init in_len length before: %d\n",
+              in_len);
+  /**
+   * If we already have a queue with this peer, ignore
+  */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "address string in mq_init: %s\n",
+              address);
+  GNUNET_CRYPTO_hash (address, strlen (address), &addr_key);
+  peer = GNUNET_CONTAINER_multihashmap_get (addr_map, &addr_key);
+  if (NULL != peer)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "ignoring transport service mq request, we already have an mq with this peer (address)\n");
+    return GNUNET_SYSERR;
+  }
+  peer = GNUNET_new (struct PeerAddress);
+  peer->address = in;
+  peer->address_len = in_len;
+  peer->target = *peer_id;
+  peer->id_rcvd = GNUNET_YES;
+  peer->is_receiver = GNUNET_YES;
+  peer->nt = GNUNET_NT_scanner_get_type (is, in, in_len);
+  peer->timeout =
+    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+  GNUNET_STATISTICS_set (stats,
+                         "# peers active",
+                         GNUNET_CONTAINER_multihashmap_size (addr_map),
+                         GNUNET_NO);
+  peer->foreign_addr =
+    sockaddr_to_udpaddr_string (peer->address, peer->address_len);
+  /**
+   * Insert peer into hashmap
+  */
+  GNUNET_CONTAINER_multihashmap_put (addr_map, &addr_key,
+                                     peer,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "mq_init added new peer to the addr map\n");
+  /**
+   * Before setting up peer mq, initiate a quic connection to the target (perform handshake w/ quiche)
+  */
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_STRONG, scid,
+                              LOCAL_CONN_ID_LEN);
+  q_conn = GNUNET_new (struct quic_conn);
+  GNUNET_memcpy (q_conn->cid, scid, LOCAL_CONN_ID_LEN);
+  peer->conn = q_conn;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "attempting to perform QUIC handshake with peer\n");
+  q_conn->conn = quiche_connect (peer->foreign_addr, scid, LOCAL_CONN_ID_LEN,
+                                 local_addr,
+                                 local_in_len, peer->address, peer->address_len,
+                                 config);
+  flush_egress (peer->conn);
+  GNUNET_free (local_addr);
+  return GNUNET_OK;
+  /**
+   * TODO: handle this
+  */
+  // if (NULL == timeout_task)
+  //   timeout_task = GNUNET_SCHEDULER_add_now (&check_timeouts, NULL);
+}
+
+
+static void
+try_connection_reversal (void *cls,
+                         const struct sockaddr *addr,
+                         socklen_t addrlen)
+{
+  /* FIXME: support reversal: #5529 */
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "No connection reversal implemented!");
+}
+
+
+/**
+ * Signature of the callback passed to #GNUNET_NAT_register() for
+ * a function to call whenever our set of 'valid' addresses changes.
+ *
+ * @param cls closure
+ * @param app_ctx[in,out] location where the app can store stuff
+ *                  on add and retrieve it on remove
+ * @param add_remove #GNUNET_YES to add a new public IP address,
+ *                   #GNUNET_NO to remove a previous (now invalid) one
+ * @param ac address class the address belongs to
+ * @param addr either the previous or the new public IP address
+ * @param addrlen actual length of the @a addr
+ */
+static void
+nat_address_cb (void *cls,
+                void **app_ctx,
+                int add_remove,
+                enum GNUNET_NAT_AddressClass ac,
+                const struct sockaddr *addr,
+                socklen_t addrlen)
+{
+  char *my_addr;
+  struct GNUNET_TRANSPORT_AddressIdentifier *ai;
+
+  if (GNUNET_YES == add_remove)
+  {
+    enum GNUNET_NetworkType nt;
+
+    GNUNET_asprintf (&my_addr,
+                     "%s-%s",
+                     COMMUNICATOR_ADDRESS_PREFIX,
+                     GNUNET_a2s (addr, addrlen));
+    nt = GNUNET_NT_scanner_get_type (is, addr, addrlen);
+    ai =
+      GNUNET_TRANSPORT_communicator_address_add (ch,
+                                                 my_addr,
+                                                 nt,
+                                                 GNUNET_TIME_UNIT_FOREVER_REL);
+    GNUNET_free (my_addr);
+    *app_ctx = ai;
+  }
+  else
+  {
+    ai = *app_ctx;
+    GNUNET_TRANSPORT_communicator_address_remove (ai);
+    *app_ctx = NULL;
+  }
+}
+
+
+/**
+ * Shutdown the QUIC communicator.
+ *
+ * @param cls NULL (always)
+ */
+static void
+do_shutdown (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "do_shutdown\n");
+  GNUNET_CONTAINER_multihashmap_iterate (addr_map, &get_peer_delete_it, NULL);
+  GNUNET_CONTAINER_multihashmap_destroy (addr_map);
+  quiche_config_free (config);
+
+  if (NULL != timeout_task)
+  {
+    GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = NULL;
+  }
+  if (NULL != read_task)
+  {
+    GNUNET_SCHEDULER_cancel (read_task);
+    read_task = NULL;
+  }
+  if (NULL != udp_sock)
+  {
+    GNUNET_break (GNUNET_OK ==
+                  GNUNET_NETWORK_socket_close (udp_sock));
+    udp_sock = NULL;
+  }
+  if (NULL != ch)
+  {
+    GNUNET_TRANSPORT_communicator_disconnect (ch);
+    ch = NULL;
+  }
+  if (NULL != ah)
+  {
+    GNUNET_TRANSPORT_application_done (ah);
+    ah = NULL;
+  }
+  if (NULL != my_private_key)
+  {
+    GNUNET_free (my_private_key);
+    my_private_key = NULL;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "do_shutdown finished\n");
+}
+
+
+static void
+sock_read (void *cls)
+{
+  struct sockaddr_storage sa;
+  struct sockaddr_in *addr_verify;
+  socklen_t salen = sizeof(sa);
+  uint8_t buf[UINT16_MAX];
+  uint8_t out[MAX_DATAGRAM_SIZE];
+  ssize_t rcvd;
+
+  ssize_t process_pkt;
+  struct QUIC_header quic_header;
+  uint8_t new_cid[LOCAL_CONN_ID_LEN];
+
+  struct PeerAddress *peer;
+  struct GNUNET_HashCode addr_key;
+
+  (void) cls;
+  quic_header.scid_len = sizeof(quic_header.scid);
+  quic_header.dcid_len = sizeof(quic_header.dcid);
+  quic_header.odcid_len = sizeof(quic_header.odcid);
+  quic_header.token_len = sizeof(quic_header.token);
+  /**
+   * Get local_addr, in_len for quiche
+  */
+  char *bindto;
+  socklen_t in_len;
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             COMMUNICATOR_CONFIG_SECTION,
+                                             "BINDTO",
+                                             &bindto))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               COMMUNICATOR_CONFIG_SECTION,
+                               "BINDTO");
+    return;
+  }
+  struct sockaddr *local_addr = udp_address_to_sockaddr (bindto, &in_len);
+
+  read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                             udp_sock,
+                                             &sock_read,
+                                             NULL);
+  while (1)
+  {
+    rcvd = GNUNET_NETWORK_socket_recvfrom (udp_sock,
+                                           buf,
+                                           sizeof(buf),
+                                           (struct sockaddr *) &sa,
+                                           &salen);
+    if (-1 == rcvd)
+    {
+      if (EAGAIN == errno)
+        break; // We are done reading data
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "recv");
+      return;
+    }
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Read %lu bytes\n", rcvd);
+
+    if (-1 == rcvd)
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "recv");
+      return;
+    }
+    /**
+     * FIXME: hashing address string vs ip/port. It is not ideal that
+     * we hash the string, instead of the binary representation, but
+     * for now it is certainly less code.
+     * Note that simply hashing the sockaddr does NOT work because the
+     * the struct is not portable.
+     */
+    const char *addr_string = sockaddr_to_udpaddr_string ((const struct
+                                                           sockaddr *) &sa,
+                                                          salen);
+    GNUNET_CRYPTO_hash (addr_string, strlen (addr_string),
+                        &addr_key);
+    GNUNET_free (addr_string);
+    peer = GNUNET_CONTAINER_multihashmap_get (addr_map, &addr_key);
+
+    if (NULL == peer)
+    {
+      /**
+       * Create new PeerAddress (receiver) with id_rcvd = false
+      */
+      peer = GNUNET_new (struct PeerAddress);
+      peer->address = GNUNET_memdup (&sa, salen);
+      peer->address_len = salen;
+      peer->id_rcvd = GNUNET_NO;
+      peer->id_sent = GNUNET_NO;
+      peer->is_receiver = GNUNET_NO;
+      peer->conn = NULL;
+      peer->foreign_addr = sockaddr_to_udpaddr_string (peer->address,
+                                                       peer->address_len);
+      /**
+       * TODO: after connection established
+      */
+      // setup_peer_mq (peer);
+      if (GNUNET_SYSERR == GNUNET_CONTAINER_multihashmap_put (addr_map,
+                                                              &addr_key,
+                                                              peer,
+                                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "tried to add duplicate address into address map\n");
+        return;
+      }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "sock_read added new peer to address map\n");
+    }
+
+    /**
+     * Parse QUIC info
+    */
+    int rc = quiche_header_info (buf, rcvd, LOCAL_CONN_ID_LEN,
+                                 &quic_header.version,
+                                 &quic_header.type, quic_header.scid,
+                                 &quic_header.scid_len, quic_header.dcid,
+                                 &quic_header.dcid_len,
+                                 quic_header.token, &quic_header.token_len);
+    if (0 > rc)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "failed to parse quic header: %d\n",
+                  rc);
+      return;
+    }
+
+    /**
+     * New QUIC connection with peer
+    */
+    if (NULL == peer->conn)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "attempting to create new connection\n");
+      if (0 == quiche_version_is_supported (quic_header.version))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "quic version negotiation initiated\n");
+        /**
+         * FIXME variables are redeclared often. Refactor either
+         * to declare variables once in the beginning or refactor into
+         * method.
+         *
+         * Write a version negotiation packet to "out"
+         */
+        ssize_t written = quiche_negotiate_version (quic_header.scid,
+                                                    quic_header.scid_len,
+                                                    quic_header.dcid,
+                                                    quic_header.dcid_len,
+                                                    out, sizeof(out));
+        if (0 > written)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                      "quiche failed to generate version negotiation packet\n");
+          return;
+        }
+        ssize_t sent = GNUNET_NETWORK_socket_sendto (udp_sock,
+                                                     out,
+                                                     written,
+                                                     (struct sockaddr*) &sa,
+                                                     salen);
+        if (sent != written)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                      "failed to send version negotiation packet to peer\n");
+          return;
+        }
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "sent %zd bytes to peer during version negotiation\n",
+                    sent);
+        return;
+      }
+
+      if (0 == quic_header.token_len)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "quic stateless retry\n");
+        mint_token (quic_header.dcid, quic_header.dcid_len, &sa, salen,
+                    quic_header.token, &quic_header.token_len);
+
+        uint8_t new_cid[LOCAL_CONN_ID_LEN];
+        GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_STRONG, new_cid,
+                                    LOCAL_CONN_ID_LEN);
+
+        ssize_t written = quiche_retry (quic_header.scid, quic_header.scid_len,
+                                        quic_header.dcid, quic_header.dcid_len,
+                                        new_cid, LOCAL_CONN_ID_LEN,
+                                        quic_header.token,
+                                        quic_header.token_len,
+                                        quic_header.version, out, sizeof(out));
+        if (0 > written)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                      "quiche failed to write retry packet\n");
+          return;
+        }
+        ssize_t sent = GNUNET_NETWORK_socket_sendto (udp_sock,
+                                                     out,
+                                                     written,
+                                                     (struct sockaddr*) &sa,
+                                                     salen);
+        if (written != sent)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "failed to send retry packet\n");
+          return;
+        }
+
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "sent %zd bytes\n", sent);
+        continue;
+      }
+
+      if (GNUNET_OK != validate_token (quic_header.token, quic_header.token_len,
+                                       &sa, salen,
+                                       quic_header.odcid,
+                                       &quic_header.odcid_len))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "invalid address validation token created\n");
+        return;
+      }
+      peer->conn = create_conn (quic_header.dcid, quic_header.dcid_len,
+                                quic_header.odcid, quic_header.odcid_len,
+                                local_addr, in_len,
+                                &sa, salen);
+      if (NULL == peer->conn)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "failed to create quic connection with peer\n");
+        return;
+      }
+    } // null connection
+
+    quiche_recv_info recv_info = {
+      (struct sockaddr *) &sa,
+      salen,
+
+      local_addr,
+      in_len,
+    };
+    /**
+     * Send our PeerIdentity if the connection is established now
+    */
+    if (quiche_conn_is_established (peer->conn->conn) && ! peer->id_sent &&
+        peer->is_receiver)
+    {
+      ssize_t send_len;
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "handshake established with peer, sending our peer id\n");
+      send_len = quiche_conn_stream_send (peer->conn->conn, STREAMID_BI,
+                                          (const uint8_t *) &my_identity,
+                                          sizeof(my_identity),
+                                          false);
+      if (0 > send_len)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "failed to write peer identity packet. quiche error: %zd\n",
+                    send_len);
+        return;
+      }
+      flush_egress (peer->conn);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "peer identity sent to peer\n");
+      peer->id_sent = GNUNET_YES;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "setting up peer mq\n");
+      setup_peer_mq (peer);
+      /**
+       * After this, we should be all good to send/recv data
+      */
+    }
+    process_pkt = quiche_conn_recv (peer->conn->conn, buf, rcvd, &recv_info);
+    if (0 > process_pkt)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "quiche failed to process received packet: %zd\n",
+                  process_pkt);
+      return;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "quiche processed %zd bytes\n", process_pkt);
+    // Check for data on all available streams if the connection is established
+    if (GNUNET_YES == quiche_conn_is_established (peer->conn->conn))
+    {
+      recv_from_streams (peer);
+    }
+    /**
+     * TODO: Should we use a list instead of hashmap?
+     * Overhead for hashing function, O(1) retrieval vs O(n) iteration with n=30?
+     *
+     * TODO: Is iteration necessary as in the quiche server example?
+    */
+    quiche_stats stats;
+    quiche_path_stats path_stats;
+
+    flush_egress (peer->conn);
+
+    if (quiche_conn_is_closed (peer->conn->conn))
+    {
+      quiche_conn_stats (peer->conn->conn, &stats);
+      quiche_conn_path_stats (peer->conn->conn, 0, &path_stats);
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "connection closed. quiche stats: sent=%zu, recv=%zu\n",
+                  stats.sent, stats.recv);
+      peer_destroy (peer);
+    }
+  }
+  GNUNET_free (local_addr);
+}
+
+
+/**
+ * Setup communicator and launch network interactions.
+ *
+ * @param cls NULL (always)
+ * @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)
+{
+  char *bindto;
+  struct sockaddr *in;
+  socklen_t in_len;
+  struct sockaddr_storage in_sto;
+  socklen_t sto_len;
+
+  (void) cls;
+  cfg = c;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             COMMUNICATOR_CONFIG_SECTION,
+                                             "BINDTO",
+                                             &bindto))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               COMMUNICATOR_CONFIG_SECTION,
+                               "BINDTO");
+    return;
+  }
+
+  in = udp_address_to_sockaddr (bindto, &in_len);
+
+  if (NULL == in)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to setup UDP socket address with path `%s'\n",
+                bindto);
+    GNUNET_free (bindto);
+    return;
+  }
+  udp_sock =
+    GNUNET_NETWORK_socket_create (in->sa_family,
+                                  SOCK_DGRAM,
+                                  IPPROTO_UDP);
+  if (NULL == udp_sock)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
+    GNUNET_free (in);
+    GNUNET_free (bindto);
+    return;
+  }
+  if (AF_INET6 == in->sa_family)
+    have_v6_socket = GNUNET_YES;
+  if (GNUNET_OK !=
+      GNUNET_NETWORK_socket_bind (udp_sock,
+                                  in,
+                                  in_len))
+  {
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
+                              "bind",
+                              bindto);
+    GNUNET_NETWORK_socket_close (udp_sock);
+    udp_sock = NULL;
+    GNUNET_free (in);
+    GNUNET_free (bindto);
+    return;
+  }
+  sto_len = sizeof(in_sto);
+  if (0 != getsockname (GNUNET_NETWORK_get_fd (udp_sock),
+                        (struct sockaddr *) &in_sto,
+                        &sto_len))
+  {
+    memcpy (&in_sto, in, in_len);
+    sto_len = in_len;
+  }
+  GNUNET_free (in);
+  GNUNET_free (bindto);
+  in = (struct sockaddr *) &in_sto;
+  in_len = sto_len;
+  GNUNET_log_from_nocheck (GNUNET_ERROR_TYPE_DEBUG,
+                           "transport",
+                           "Bound to `%s'\n",
+                           GNUNET_a2s ((const struct sockaddr *) &in_sto,
+                                       sto_len));
+  switch (in->sa_family)
+  {
+  case AF_INET:
+    my_port = ntohs (((struct sockaddr_in *) in)->sin_port);
+    break;
+
+  case AF_INET6:
+    my_port = ntohs (((struct sockaddr_in6 *) in)->sin6_port);
+    break;
+
+  default:
+    GNUNET_break (0);
+    my_port = 0;
+  }
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+  /**
+   * Setup QUICHE configuration
+  */
+  config = quiche_config_new (QUICHE_PROTOCOL_VERSION);
+  quiche_config_verify_peer (config, false);
+  /**
+   * TODO: configure TLS cert
+  */
+  quiche_config_load_cert_chain_from_pem_file (config, "./cert.crt");
+  quiche_config_load_priv_key_from_pem_file (config, "./cert.key");
+  quiche_config_set_application_protos (config,
+                                        (uint8_t *)
+                                        "\x0ahq-interop\x05hq-29\x05hq-28\x05hq-27\x08http/0.9",
+                                        38);
+  quiche_config_set_max_idle_timeout (config, 5000);
+  quiche_config_set_max_recv_udp_payload_size (config, 1200);
+  quiche_config_set_max_send_udp_payload_size (config, 1200);
+  quiche_config_set_initial_max_data (config, 10000000);
+  quiche_config_set_initial_max_stream_data_bidi_local (config, 1000000);
+  quiche_config_set_initial_max_stream_data_bidi_remote (config, 1000000);
+  quiche_config_set_initial_max_stream_data_uni (config, 1000000);
+  quiche_config_set_initial_max_streams_bidi (config, 100);
+  quiche_config_set_initial_max_streams_uni (config, 100);
+  quiche_config_set_cc_algorithm (config, QUICHE_CC_RENO);
+  quiche_config_set_disable_active_migration (config, true);
+  addr_map = GNUNET_CONTAINER_multihashmap_create (2, GNUNET_NO);
+  /**
+   * Get our public key for initial packet
+  */
+  my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
+  if (NULL == my_private_key)
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_ERROR,
+      _ (
+        "Transport service is lacking key configuration settings. Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key);
+  /* start reading */
+  read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                             udp_sock,
+                                             &sock_read,
+                                             NULL);
+  ch = GNUNET_TRANSPORT_communicator_connect (cfg,
+                                              COMMUNICATOR_CONFIG_SECTION,
+                                              COMMUNICATOR_ADDRESS_PREFIX,
+                                              GNUNET_TRANSPORT_CC_RELIABLE,
+                                              &mq_init,
+                                              NULL,
+                                              &notify_cb,
+                                              NULL);
+  is = GNUNET_NT_scanner_init ();
+  nat = GNUNET_NAT_register (cfg,
+                             COMMUNICATOR_CONFIG_SECTION,
+                             IPPROTO_UDP,
+                             1 /* one address */,
+                             (const struct sockaddr **) &in,
+                             &in_len,
+                             &nat_address_cb,
+                             try_connection_reversal,
+                             NULL /* closure */);
+  if (NULL == ch)
+  {
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  ah = GNUNET_TRANSPORT_application_init (cfg);
+  if (NULL == ah)
+  {
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  /* start broadcasting */
+  // if (GNUNET_YES !=
+  //     GNUNET_CONFIGURATION_get_value_yesno (cfg,
+  //                                           COMMUNICATOR_CONFIG_SECTION,
+  //                                           "DISABLE_BROADCAST"))
+  // {
+  //   broadcast_task = GNUNET_SCHEDULER_add_now (&do_broadcast, NULL);
+  // }
+}
+
+
+int
+main (int argc, char *const *argv)
+{
+  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_OPTION_END
+  };
+  int ret;
+
+  GNUNET_log_from_nocheck (GNUNET_ERROR_TYPE_DEBUG,
+                           "transport",
+                           "Starting quic communicator\n");
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
+    return 2;
+
+  ret = (GNUNET_OK == GNUNET_PROGRAM_run (argc,
+                                          argv,
+                                          "gnunet-communicator-quic",
+                                          _ ("GNUnet QUIC communicator"),
+                                          options,
+                                          &run,
+                                          NULL))
+          ? 0
+          : 1;
+  GNUNET_free_nz ((void *) argv);
+  return ret;
+}
diff --git a/src/service/transport/gnunet-communicator-tcp.c b/src/service/transport/gnunet-communicator-tcp.c
new file mode 100644
index 000000000..5d9b9055f
--- /dev/null
+++ b/src/service/transport/gnunet-communicator-tcp.c
@@ -0,0 +1,4182 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2010-2014, 2018, 2019 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 transport/gnunet-communicator-tcp.c
+ * @brief Transport plugin using TCP.
+ * @author Christian Grothoff
+ *
+ * TODO:
+ * - support NAT connection reversal method (#5529)
+ * - support other TCP-specific NAT traversal methods (#5531)
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_core_service.h"
+#include "gnunet_peerstore_service.h"
+#include "gnunet_protocols.h"
+#include "gnunet_signatures.h"
+#include "gnunet_constants.h"
+#include "gnunet_nat_service.h"
+#include "gnunet_statistics_service.h"
+#include "gnunet_transport_communication_service.h"
+#include "gnunet_resolver_service.h"
+
+
+/**
+ * How long until we give up on establishing an NAT connection?
+ * Must be > 4 RTT
+ */
+#define NAT_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
+
+/**
+ * How long do we believe our addresses to remain up (before
+ * the other peer should revalidate).
+ */
+#define ADDRESS_VALIDITY_PERIOD \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
+
+/**
+ * How many messages do we keep at most in the queue to the
+ * transport service before we start to drop (default,
+ * can be changed via the configuration file).
+ * Should be _below_ the level of the communicator API, as
+ * otherwise we may read messages just to have them dropped
+ * by the communicator API.
+ */
+#define DEFAULT_MAX_QUEUE_LENGTH 8
+
+/**
+ * Size of our IO buffers for ciphertext data. Must be at
+ * least UINT_MAX + sizeof (struct TCPBox).
+ */
+#define BUF_SIZE (2 * 64 * 1024 + sizeof(struct TCPBox))
+
+/**
+ * How often do we rekey based on time (at least)
+ */
+#define DEFAULT_REKEY_INTERVAL GNUNET_TIME_UNIT_DAYS
+
+/**
+ * How long do we wait until we must have received the initial KX?
+ */
+#define PROTO_QUEUE_TIMEOUT GNUNET_TIME_UNIT_MINUTES
+
+/**
+ * How often do we rekey based on number of bytes transmitted?
+ * (additionally randomized). Currently 400 MB
+ */
+#define REKEY_MAX_BYTES (1024LLU * 1024 * 400)
+
+/**
+ * Size of the initial key exchange message sent first in both
+ * directions.
+ */
+#define INITIAL_KX_SIZE                           \
+        (sizeof(struct GNUNET_CRYPTO_EcdhePublicKey)   \
+         + sizeof(struct TCPConfirmation))
+
+/**
+ * Size of the initial core key exchange messages.
+ */
+#define INITIAL_CORE_KX_SIZE          \
+        (sizeof(struct EphemeralKeyMessage)   \
+         + sizeof(struct PingMessage) \
+         + sizeof(struct PongMessage))
+
+/**
+ * Address prefix used by the communicator.
+ */
+#define COMMUNICATOR_ADDRESS_PREFIX "tcp"
+
+/**
+ * Configuration section used by the communicator.
+ */
+#define COMMUNICATOR_CONFIG_SECTION "communicator-tcp"
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+
+/**
+ * Signature we use to verify that the ephemeral key was really chosen by
+ * the specified sender.
+ */
+struct TcpHandshakeSignature
+{
+  /**
+   * Purpose must be #GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_HANDSHAKE
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+
+  /**
+   * Identity of the inititor of the TCP connection (TCP client).
+   */
+  struct GNUNET_PeerIdentity sender;
+
+  /**
+   * Presumed identity of the target of the TCP connection (TCP server)
+   */
+  struct GNUNET_PeerIdentity receiver;
+
+  /**
+   * Ephemeral key used by the @e sender.
+   */
+  struct GNUNET_CRYPTO_EcdhePublicKey ephemeral;
+
+  /**
+   * Monotonic time of @e sender, to possibly help detect replay attacks
+   * (if receiver persists times by sender).
+   */
+  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
+
+  /**
+   * Challenge value used to protect against replay attack, if there is no stored monotonic time value.
+   */
+  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
+};
+
+/**
+ * Signature we use to verify that the ack from the receiver of the ephemeral key was really send by
+ * the specified sender.
+ */
+struct TcpHandshakeAckSignature
+{
+  /**
+   * Purpose must be #GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_HANDSHAKE_ACK
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+
+  /**
+   * Identity of the inititor of the TCP connection (TCP client).
+   */
+  struct GNUNET_PeerIdentity sender;
+
+  /**
+   * Presumed identity of the target of the TCP connection (TCP server)
+   */
+  struct GNUNET_PeerIdentity receiver;
+
+  /**
+   * Monotonic time of @e sender, to possibly help detect replay attacks
+   * (if receiver persists times by sender).
+   */
+  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
+
+  /**
+   * Challenge value used to protect against replay attack, if there is no stored monotonic time value.
+   */
+  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
+};
+
+/**
+ * Encrypted continuation of TCP initial handshake.
+ */
+struct TCPConfirmation
+{
+  /**
+   * Sender's identity
+   */
+  struct GNUNET_PeerIdentity sender;
+
+  /**
+   * Sender's signature of type #GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_HANDSHAKE
+   */
+  struct GNUNET_CRYPTO_EddsaSignature sender_sig;
+
+  /**
+   * Monotonic time of @e sender, to possibly help detect replay attacks
+   * (if receiver persists times by sender).
+   */
+  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
+
+  /**
+   * Challenge value used to protect against replay attack, if there is no stored monotonic time value.
+   */
+  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
+
+};
+
+/**
+ * Ack for the encrypted continuation of TCP initial handshake.
+ */
+struct TCPConfirmationAck
+{
+
+
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_CONFIRMATION_ACK.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Sender's identity
+   */
+  struct GNUNET_PeerIdentity sender;
+
+  /**
+   * Sender's signature of type #GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_HANDSHAKE_ACK
+   */
+  struct GNUNET_CRYPTO_EddsaSignature sender_sig;
+
+  /**
+   * Monotonic time of @e sender, to possibly help detect replay attacks
+   * (if receiver persists times by sender).
+   */
+  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
+
+  /**
+   * Challenge value used to protect against replay attack, if there is no stored monotonic time value.
+   */
+  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
+
+};
+
+/**
+ * TCP message box.  Always sent encrypted!
+ */
+struct TCPBox
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX.  Warning: the
+   * header size EXCLUDES the size of the `struct TCPBox`. We usually
+   * never do this, but here the payload may truly be 64k *after* the
+   * TCPBox (as we have no MTU)!!
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * HMAC for the following encrypted message.  Yes, we MUST use
+   * mac-then-encrypt here, as we want to hide the message sizes on
+   * the wire (zero plaintext design!).  Using CTR mode, padding oracle
+   * attacks do not apply.  Besides, due to the use of ephemeral keys
+   * (hopefully with effective replay protection from monotonic time!)
+   * the attacker is limited in using the oracle.
+   */
+  struct GNUNET_ShortHashCode hmac;
+
+  /* followed by as may bytes of payload as indicated in @e header,
+     excluding the TCPBox itself! */
+};
+
+
+/**
+ * TCP rekey message box.  Always sent encrypted!  Data after
+ * this message will use the new key.
+ */
+struct TCPRekey
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * HMAC for the following encrypted message.  Yes, we MUST use
+   * mac-then-encrypt here, as we want to hide the message sizes on
+   * the wire (zero plaintext design!).  Using CTR mode padding oracle
+   * attacks do not apply.  Besides, due to the use of ephemeral keys
+   * (hopefully with effective replay protection from monotonic time!)
+   * the attacker is limited in using the oracle.
+   */
+  struct GNUNET_ShortHashCode hmac;
+
+  /**
+   * New ephemeral key.
+   */
+  struct GNUNET_CRYPTO_EcdhePublicKey ephemeral;
+
+  /**
+   * Sender's signature of type #GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_REKEY
+   */
+  struct GNUNET_CRYPTO_EddsaSignature sender_sig;
+
+  /**
+   * Monotonic time of @e sender, to possibly help detect replay attacks
+   * (if receiver persists times by sender).
+   */
+  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
+};
+
+/**
+ * Signature we use to verify that the ephemeral key was really chosen by
+ * the specified sender.
+ */
+struct TcpRekeySignature
+{
+  /**
+   * Purpose must be #GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_REKEY
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+
+  /**
+   * Identity of the inititor of the TCP connection (TCP client).
+   */
+  struct GNUNET_PeerIdentity sender;
+
+  /**
+   * Presumed identity of the target of the TCP connection (TCP server)
+   */
+  struct GNUNET_PeerIdentity receiver;
+
+  /**
+   * Ephemeral key used by the @e sender.
+   */
+  struct GNUNET_CRYPTO_EcdhePublicKey ephemeral;
+
+  /**
+   * Monotonic time of @e sender, to possibly help detect replay attacks
+   * (if receiver persists times by sender).
+   */
+  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
+};
+
+/**
+ * TCP finish. Sender asks for the connection to be closed.
+ * Needed/useful in case we drop RST/FIN packets on the GNUnet
+ * port due to the possibility of malicious RST/FIN injection.
+ */
+struct TCPFinish
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * HMAC for the following encrypted message.  Yes, we MUST use
+   * mac-then-encrypt here, as we want to hide the message sizes on
+   * the wire (zero plaintext design!).  Using CTR mode padding oracle
+   * attacks do not apply.  Besides, due to the use of ephemeral keys
+   * (hopefully with effective replay protection from monotonic time!)
+   * the attacker is limited in using the oracle.
+   */
+  struct GNUNET_ShortHashCode hmac;
+};
+
+/**
+ * Basically a WELCOME message, but with the purpose
+ * of giving the waiting peer a client handle to use
+ */
+struct TCPNATProbeMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_NAT_PROBE.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Identity of the sender of the message.
+   */
+  struct GNUNET_PeerIdentity clientIdentity;
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+/**
+ * Struct for pending nat reversals.
+ */
+struct PendingReversal
+{
+  /*
+   * Timeout task.
+   */
+  struct GNUNET_SCHEDULER_Task *timeout_task;
+
+  /**
+   * To whom are we like to talk to.
+   */
+  struct GNUNET_PeerIdentity target;
+
+  /**
+   * Address the reversal was send to.
+   */
+  struct sockaddr *in;
+};
+
+/**
+ * Struct to use as closure.
+ */
+struct ListenTask
+{
+  /**
+   * ID of listen task
+   */
+  struct GNUNET_SCHEDULER_Task *listen_task;
+
+  /**
+   * Listen socket.
+   */
+  struct GNUNET_NETWORK_Handle *listen_sock;
+};
+
+/**
+ * Handle for a queue.
+ */
+struct Queue
+{
+  /**
+   * To whom are we talking to.
+   */
+  struct GNUNET_PeerIdentity target;
+
+  /**
+   * Listen socket.
+   */
+  struct GNUNET_NETWORK_Handle *listen_sock;
+
+  /**
+   * socket that we transmit all data with on this queue
+   */
+  struct GNUNET_NETWORK_Handle *sock;
+
+  /**
+   * cipher for decryption of incoming data.
+   */
+  gcry_cipher_hd_t in_cipher;
+
+  /**
+   * cipher for encryption of outgoing data.
+   */
+  gcry_cipher_hd_t out_cipher;
+
+  /**
+   * Key in hash map
+   */
+  struct GNUNET_HashCode key;
+
+  /**
+   * Shared secret for HMAC verification on incoming data.
+   */
+  struct GNUNET_HashCode in_hmac;
+
+  /**
+   * Shared secret for HMAC generation on outgoing data, ratcheted after
+   * each operation.
+   */
+  struct GNUNET_HashCode out_hmac;
+
+  /**
+   * ID of read task for this connection.
+   */
+  struct GNUNET_SCHEDULER_Task *read_task;
+
+  /**
+   * ID of write task for this connection.
+   */
+  struct GNUNET_SCHEDULER_Task *write_task;
+
+  /**
+   * Address of the other peer.
+   */
+  struct sockaddr *address;
+
+  /**
+   * How many more bytes may we sent with the current @e out_cipher
+   * before we should rekey?
+   */
+  uint64_t rekey_left_bytes;
+
+  /**
+   * Until what time may we sent with the current @e out_cipher
+   * before we should rekey?
+   */
+  struct GNUNET_TIME_Absolute rekey_time;
+
+  /**
+   * Length of the address.
+   */
+  socklen_t address_len;
+
+  /**
+   * Message queue we are providing for the #ch.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * handle for this queue with the #ch.
+   */
+  struct GNUNET_TRANSPORT_QueueHandle *qh;
+
+  /**
+   * Number of bytes we currently have in our write queue.
+   */
+  unsigned long long bytes_in_queue;
+
+  /**
+   * Buffer for reading ciphertext from network into.
+   */
+  char cread_buf[BUF_SIZE];
+
+  /**
+   * buffer for writing ciphertext to network.
+   */
+  char cwrite_buf[BUF_SIZE];
+
+  /**
+   * Plaintext buffer for decrypted plaintext.
+   */
+  char pread_buf[UINT16_MAX + 1 + sizeof(struct TCPBox)];
+
+  /**
+   * Plaintext buffer for messages to be encrypted.
+   */
+  char pwrite_buf[UINT16_MAX + 1 + sizeof(struct TCPBox)];
+
+  /**
+   * At which offset in the ciphertext read buffer should we
+   * append more ciphertext for transmission next?
+   */
+  size_t cread_off;
+
+  /**
+   * At which offset in the ciphertext write buffer should we
+   * append more ciphertext from reading next?
+   */
+  size_t cwrite_off;
+
+  /**
+   * At which offset in the plaintext input buffer should we
+   * append more plaintext from decryption next?
+   */
+  size_t pread_off;
+
+  /**
+   * At which offset in the plaintext output buffer should we
+   * append more plaintext for encryption next?
+   */
+  size_t pwrite_off;
+
+  /**
+   * Timeout for this queue.
+   */
+  struct GNUNET_TIME_Absolute timeout;
+
+  /**
+   * How may messages did we pass from this queue to CORE for which we
+   * have yet to receive an acknoweldgement that CORE is done with
+   * them? If "large" (or even just non-zero), we should throttle
+   * reading to provide flow control.  See also #DEFAULT_MAX_QUEUE_LENGTH
+   * and #max_queue_length.
+   */
+  unsigned int backpressure;
+
+  /**
+   * Which network type does this queue use?
+   */
+  enum GNUNET_NetworkType nt;
+
+  /**
+   * The connection status of this queue.
+   */
+  enum GNUNET_TRANSPORT_ConnectionStatus cs;
+
+  /**
+   * Is MQ awaiting a #GNUNET_MQ_impl_send_continue() call?
+   */
+  int mq_awaits_continue;
+
+  /**
+   * Did we enqueue a finish message and are closing down the queue?
+   */
+  int finishing;
+
+  /**
+   * Did we technically destroy this queue, but kept the allocation
+   * around because of @e backpressure not being zero yet? Used
+   * simply to delay the final #GNUNET_free() operation until
+   * #core_read_finished_cb() has been called.
+   */
+  int destroyed;
+
+  /**
+   * #GNUNET_YES if we just rekeyed and must thus possibly
+   * re-decrypt ciphertext.
+   */
+  int rekeyed;
+
+  /**
+   * Monotonic time value for rekey message.
+   */
+  struct GNUNET_TIME_AbsoluteNBO rekey_monotonic_time;
+
+  /**
+   * Monotonic time value for handshake message.
+   */
+  struct GNUNET_TIME_AbsoluteNBO handshake_monotonic_time;
+
+  /**
+   * Monotonic time value for handshake ack message.
+   */
+  struct GNUNET_TIME_AbsoluteNBO handshake_ack_monotonic_time;
+
+  /**
+   * Challenge value used to protect against replay attack, if there is no stored monotonic time value.
+   */
+  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
+
+  /**
+   * Challenge value received. In case of inbound connection we have to remember the value, because we send the challenge back later after we received the GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_CONFIRMATION_ACK.
+   */
+  struct GNUNET_CRYPTO_ChallengeNonceP challenge_received;
+
+  /**
+   * Iteration Context for retrieving the monotonic time send with key for rekeying.
+   */
+  struct GNUNET_PEERSTORE_IterateContext *rekey_monotime_get;
+
+  /**
+   * Iteration Context for retrieving the monotonic time send with the handshake.
+   */
+  struct GNUNET_PEERSTORE_IterateContext *handshake_monotime_get;
+
+  /**
+   * Iteration Context for retrieving the monotonic time send with the handshake ack.
+   */
+  struct GNUNET_PEERSTORE_IterateContext *handshake_ack_monotime_get;
+
+  /**
+   * Store Context for retrieving the monotonic time send with key for rekeying.
+   */
+  struct GNUNET_PEERSTORE_StoreContext *rekey_monotime_sc;
+
+  /**
+   * Store Context for retrieving the monotonic time send with the handshake.
+   */
+  struct GNUNET_PEERSTORE_StoreContext *handshake_monotime_sc;
+
+  /**
+   * Store Context for retrieving the monotonic time send with the handshake ack.
+   */
+  struct GNUNET_PEERSTORE_StoreContext *handshake_ack_monotime_sc;
+
+  /**
+   * Size of data received without KX challenge played back.
+   */
+  // TODO remove?
+  size_t unverified_size;
+
+  /**
+   * Has the initial (core) handshake already happened?
+   */
+  int initial_core_kx_done;
+};
+
+
+/**
+ * Handle for an incoming connection where we do not yet have enough
+ * information to setup a full queue.
+ */
+struct ProtoQueue
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct ProtoQueue *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct ProtoQueue *prev;
+
+  /**
+   * Listen socket.
+   */
+  struct GNUNET_NETWORK_Handle *listen_sock;
+
+  /**
+   * socket that we transmit all data with on this queue
+   */
+  struct GNUNET_NETWORK_Handle *sock;
+
+  /**
+   * ID of write task for this connection.
+   */
+  struct GNUNET_SCHEDULER_Task *write_task;
+
+  /**
+   * buffer for writing struct TCPNATProbeMessage to network.
+   */
+  char write_buf[sizeof (struct TCPNATProbeMessage)];
+
+  /**
+   * Offset of the buffer?
+   */
+  size_t write_off;
+
+  /**
+   * ID of read task for this connection.
+   */
+  struct GNUNET_SCHEDULER_Task *read_task;
+
+  /**
+   * Address of the other peer.
+   */
+  struct sockaddr *address;
+
+  /**
+   * Length of the address.
+   */
+  socklen_t address_len;
+
+  /**
+   * Timeout for this protoqueue.
+   */
+  struct GNUNET_TIME_Absolute timeout;
+
+  /**
+   * Buffer for reading all the information we need to upgrade from
+   * protoqueue to queue.
+   */
+  char ibuf[INITIAL_KX_SIZE];
+
+  /**
+   * Current offset for reading into @e ibuf.
+   */
+  size_t ibuf_off;
+};
+
+/**
+ * In case of port only configuration we like to bind to ipv4 and ipv6 addresses.
+ */
+struct PortOnlyIpv4Ipv6
+{
+  /**
+   * Ipv4 address we like to bind to.
+   */
+  struct sockaddr *addr_ipv4;
+
+  /**
+   * Length of ipv4 address.
+   */
+  socklen_t addr_len_ipv4;
+
+  /**
+   * Ipv6 address we like to bind to.
+   */
+  struct sockaddr *addr_ipv6;
+
+  /**
+   * Length of ipv6 address.
+   */
+  socklen_t addr_len_ipv6;
+
+};
+
+/**
+ * DLL to store the addresses we like to register at NAT service.
+ */
+struct Addresses
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct Addresses *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct Addresses *prev;
+
+  /**
+   * Address we like to register at NAT service.
+   */
+  struct sockaddr *addr;
+
+  /**
+   * Length of address we like to register at NAT service.
+   */
+  socklen_t addr_len;
+
+};
+
+
+/**
+ * Maximum queue length before we stop reading towards the transport service.
+ */
+static unsigned long long max_queue_length;
+
+/**
+ * For logging statistics.
+ */
+static struct GNUNET_STATISTICS_Handle *stats;
+
+/**
+ * Our environment.
+ */
+static struct GNUNET_TRANSPORT_CommunicatorHandle *ch;
+
+/**
+ * Queues (map from peer identity to `struct Queue`)
+ */
+static struct GNUNET_CONTAINER_MultiHashMap *queue_map;
+
+/**
+ * ListenTasks (map from socket to `struct ListenTask`)
+ */
+static struct GNUNET_CONTAINER_MultiHashMap *lt_map;
+
+/**
+ * Our public key.
+ */
+static struct GNUNET_PeerIdentity my_identity;
+
+/**
+ * The rekey byte maximum
+ */
+static unsigned long long rekey_max_bytes;
+
+/**
+ * The rekey interval
+ */
+static struct GNUNET_TIME_Relative rekey_interval;
+
+/**
+ * Our private key.
+ */
+static struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
+
+/**
+ * Our configuration.
+ */
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Network scanner to determine network types.
+ */
+static struct GNUNET_NT_InterfaceScanner *is;
+
+/**
+ * Connection to NAT service.
+ */
+static struct GNUNET_NAT_Handle *nat;
+
+/**
+ * Protoqueues DLL head.
+ */
+static struct ProtoQueue *proto_head;
+
+/**
+ * Protoqueues DLL tail.
+ */
+static struct ProtoQueue *proto_tail;
+
+/**
+ * Handle for DNS lookup of bindto address
+ */
+struct GNUNET_RESOLVER_RequestHandle *resolve_request_handle;
+
+/**
+ * Head of DLL with addresses we like to register at NAT servcie.
+ */
+static struct Addresses *addrs_head;
+
+/**
+ * Head of DLL with addresses we like to register at NAT servcie.
+ */
+static struct Addresses *addrs_tail;
+
+/**
+ * Number of addresses in the DLL for register at NAT service.
+ */
+static int addrs_lens;
+
+/**
+ * Database for peer's HELLOs.
+ */
+static struct GNUNET_PEERSTORE_Handle *peerstore;
+
+/**
+* A flag indicating we are already doing a shutdown.
+*/
+static int shutdown_running = GNUNET_NO;
+
+/**
+ * IPv6 disabled.
+ */
+static int disable_v6;
+
+/**
+ * The port the communicator should be assigned to.
+ */
+static unsigned int bind_port;
+
+/**
+ *  Map of pending reversals.
+ */
+static struct GNUNET_CONTAINER_MultiHashMap *pending_reversals;
+
+/**
+ * We have been notified that our listen socket has something to
+ * read. Do the read and reschedule this function to be called again
+ * once more is available.
+ *
+ * @param cls NULL
+ */
+static void
+listen_cb (void *cls);
+
+/**
+ * Functions with this signature are called whenever we need
+ * to close a queue due to a disconnect or failure to
+ * establish a connection.
+ *
+ * @param queue queue to close down
+ */
+static void
+queue_destroy (struct Queue *queue)
+{
+  struct ListenTask *lt = NULL;
+  struct GNUNET_HashCode h_sock;
+  int sockfd;
+
+  if (NULL != queue->listen_sock)
+  {
+    sockfd = GNUNET_NETWORK_get_fd (queue->listen_sock);
+    GNUNET_CRYPTO_hash (&sockfd,
+                        sizeof(int),
+                        &h_sock);
+
+    lt = GNUNET_CONTAINER_multihashmap_get (lt_map, &h_sock);
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Disconnecting queue for peer `%s'\n",
+              GNUNET_i2s (&queue->target));
+  if (NULL != queue->rekey_monotime_sc)
+  {
+    GNUNET_PEERSTORE_store_cancel (queue->rekey_monotime_sc);
+    queue->rekey_monotime_sc = NULL;
+  }
+  if (NULL != queue->handshake_monotime_sc)
+  {
+    GNUNET_PEERSTORE_store_cancel (queue->handshake_monotime_sc);
+    queue->handshake_monotime_sc = NULL;
+  }
+  if (NULL != queue->handshake_ack_monotime_sc)
+  {
+    GNUNET_PEERSTORE_store_cancel (queue->handshake_ack_monotime_sc);
+    queue->handshake_ack_monotime_sc = NULL;
+  }
+  if (NULL != queue->rekey_monotime_get)
+  {
+    GNUNET_PEERSTORE_iteration_stop (queue->rekey_monotime_get);
+    queue->rekey_monotime_get = NULL;
+  }
+  if (NULL != queue->handshake_monotime_get)
+  {
+    GNUNET_PEERSTORE_iteration_stop (queue->handshake_monotime_get);
+    queue->handshake_monotime_get = NULL;
+  }
+  if (NULL != queue->handshake_ack_monotime_get)
+  {
+    GNUNET_PEERSTORE_iteration_stop (queue->handshake_ack_monotime_get);
+    queue->handshake_ack_monotime_get = NULL;
+  }
+  if (NULL != queue->qh)
+  {
+    GNUNET_TRANSPORT_communicator_mq_del (queue->qh);
+    queue->qh = NULL;
+  }
+  GNUNET_assert (
+    GNUNET_YES ==
+    GNUNET_CONTAINER_multihashmap_remove (queue_map, &queue->key, queue));
+  GNUNET_STATISTICS_set (stats,
+                         "# queues active",
+                         GNUNET_CONTAINER_multihashmap_size (queue_map),
+                         GNUNET_NO);
+  if (NULL != queue->read_task)
+  {
+    GNUNET_SCHEDULER_cancel (queue->read_task);
+    queue->read_task = NULL;
+  }
+  if (NULL != queue->write_task)
+  {
+    GNUNET_SCHEDULER_cancel (queue->write_task);
+    queue->write_task = NULL;
+  }
+  if (GNUNET_SYSERR == GNUNET_NETWORK_socket_close (queue->sock))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "closing socket failed\n");
+  }
+  gcry_cipher_close (queue->in_cipher);
+  gcry_cipher_close (queue->out_cipher);
+  GNUNET_free (queue->address);
+  if (0 != queue->backpressure)
+    queue->destroyed = GNUNET_YES;
+  else
+    GNUNET_free (queue);
+
+  if (NULL == lt)
+    return;
+
+  if ((! shutdown_running) && (NULL == lt->listen_task))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "add read net listen\n");
+    lt->listen_task = GNUNET_SCHEDULER_add_read_net (
+      GNUNET_TIME_UNIT_FOREVER_REL,
+      lt->listen_sock,
+      &listen_cb,
+      lt);
+  }
+  else
+    GNUNET_free (lt);
+}
+
+
+/**
+ * Compute @a mac over @a buf, and ratched the @a hmac_secret.
+ *
+ * @param[in,out] hmac_secret secret for HMAC calculation
+ * @param buf buffer to MAC
+ * @param buf_size number of bytes in @a buf
+ * @param[out] smac where to write the HMAC
+ */
+static void
+calculate_hmac (struct GNUNET_HashCode *hmac_secret,
+                const void *buf,
+                size_t buf_size,
+                struct GNUNET_ShortHashCode *smac)
+{
+  struct GNUNET_HashCode mac;
+
+  GNUNET_CRYPTO_hmac_raw (hmac_secret,
+                          sizeof(struct GNUNET_HashCode),
+                          buf,
+                          buf_size,
+                          &mac);
+  /* truncate to `struct GNUNET_ShortHashCode` */
+  memcpy (smac, &mac, sizeof(struct GNUNET_ShortHashCode));
+  /* ratchet hmac key */
+  GNUNET_CRYPTO_hash (hmac_secret,
+                      sizeof(struct GNUNET_HashCode),
+                      hmac_secret);
+}
+
+
+/**
+ * Append a 'finish' message to the outgoing transmission. Once the
+ * finish has been transmitted, destroy the queue.
+ *
+ * @param queue queue to shut down nicely
+ */
+static void
+queue_finish (struct Queue *queue)
+{
+  struct TCPFinish fin;
+
+  memset (&fin, 0, sizeof(fin));
+  fin.header.size = htons (sizeof(fin));
+  fin.header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH);
+  calculate_hmac (&queue->out_hmac, &fin, sizeof(fin), &fin.hmac);
+  /* if there is any message left in pwrite_buf, we
+     overwrite it (possibly dropping the last message
+     from CORE hard here) */
+  memcpy (queue->pwrite_buf, &fin, sizeof(fin));
+  queue->pwrite_off = sizeof(fin);
+  /* This flag will ensure that #queue_write() no longer
+     notifies CORE about the possibility of sending
+     more data, and that #queue_write() will call
+  #queue_destroy() once the @c fin was fully written. */
+  queue->finishing = GNUNET_YES;
+}
+
+
+/**
+ * Queue read task. If we hit the timeout, disconnect it
+ *
+ * @param cls the `struct Queue *` to disconnect
+ */
+static void
+queue_read (void *cls);
+
+
+/**
+ * Core tells us it is done processing a message that transport
+ * received on a queue with status @a success.
+ *
+ * @param cls a `struct Queue *` where the message originally came from
+ * @param success #GNUNET_OK on success
+ */
+static void
+core_read_finished_cb (void *cls, int success)
+{
+  struct Queue *queue = cls;
+  if (GNUNET_OK != success)
+    GNUNET_STATISTICS_update (stats,
+                              "# messages lost in communicator API towards CORE",
+                              1,
+                              GNUNET_NO);
+  if (NULL == queue)
+    return;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "backpressure %u\n",
+              queue->backpressure);
+
+  queue->backpressure--;
+  /* handle deferred queue destruction */
+  if ((queue->destroyed) && (0 == queue->backpressure))
+  {
+    GNUNET_free (queue);
+    return;
+  }
+  else if (GNUNET_YES != queue->destroyed)
+  {
+    queue->timeout =
+      GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT
+                                        );
+    /* possibly unchoke reading, now that CORE made progress */
+    if (NULL == queue->read_task)
+      queue->read_task =
+        GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_absolute_get_remaining (
+                                         queue->timeout),
+                                       queue->sock,
+                                       &queue_read,
+                                       queue);
+  }
+}
+
+
+/**
+ * We received @a plaintext_len bytes of @a plaintext on @a queue.
+ * Pass it on to CORE.  If transmission is actually happening,
+ * increase backpressure counter.
+ *
+ * @param queue the queue that received the plaintext
+ * @param plaintext the plaintext that was received
+ * @param plaintext_len number of bytes of plaintext received
+ */
+static void
+pass_plaintext_to_core (struct Queue *queue,
+                        const void *plaintext,
+                        size_t plaintext_len)
+{
+  const struct GNUNET_MessageHeader *hdr = plaintext;
+  int ret;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "pass message from %s to core\n",
+              GNUNET_i2s (&queue->target));
+
+  if (ntohs (hdr->size) != plaintext_len)
+  {
+    /* NOTE: If we ever allow multiple CORE messages in one
+       BOX, this will have to change! */
+    GNUNET_break (0);
+    return;
+  }
+  ret = GNUNET_TRANSPORT_communicator_receive (ch,
+                                               &queue->target,
+                                               hdr,
+                                               ADDRESS_VALIDITY_PERIOD,
+                                               &core_read_finished_cb,
+                                               queue);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "passed to core\n");
+  if (GNUNET_OK == ret)
+    queue->backpressure++;
+  GNUNET_break (GNUNET_NO != ret);  /* backpressure not working!? */
+  if (GNUNET_SYSERR == ret)
+    GNUNET_STATISTICS_update (stats,
+                              "# bytes lost due to CORE not running",
+                              plaintext_len,
+                              GNUNET_NO);
+}
+
+
+/**
+ * Setup @a cipher based on shared secret @a dh and decrypting
+ * peer @a pid.
+ *
+ * @param dh shared secret
+ * @param pid decrypting peer's identity
+ * @param[out] cipher cipher to initialize
+ * @param[out] hmac_key HMAC key to initialize
+ */
+static void
+setup_cipher (const struct GNUNET_HashCode *dh,
+              const struct GNUNET_PeerIdentity *pid,
+              gcry_cipher_hd_t *cipher,
+              struct GNUNET_HashCode *hmac_key)
+{
+  char key[256 / 8];
+  char ctr[128 / 8];
+
+  GNUNET_assert (0 == gcry_cipher_open (cipher,
+                                        GCRY_CIPHER_AES256 /* low level: go for speed */
+                                        ,
+                                        GCRY_CIPHER_MODE_CTR,
+                                        0 /* flags */));
+  GNUNET_assert (GNUNET_YES == GNUNET_CRYPTO_kdf (key,
+                                                  sizeof(key),
+                                                  "TCP-key",
+                                                  strlen ("TCP-key"),
+                                                  dh,
+                                                  sizeof(*dh),
+                                                  pid,
+                                                  sizeof(*pid),
+                                                  NULL,
+                                                  0));
+  GNUNET_assert (0 == gcry_cipher_setkey (*cipher, key, sizeof(key)));
+  GNUNET_assert (GNUNET_YES == GNUNET_CRYPTO_kdf (ctr,
+                                                  sizeof(ctr),
+                                                  "TCP-ctr",
+                                                  strlen ("TCP-ctr"),
+                                                  dh,
+                                                  sizeof(*dh),
+                                                  pid,
+                                                  sizeof(*pid),
+                                                  NULL,
+                                                  0));
+  gcry_cipher_setctr (*cipher, ctr, sizeof(ctr));
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CRYPTO_kdf (hmac_key,
+                                    sizeof(struct GNUNET_HashCode),
+                                    "TCP-hmac",
+                                    strlen ("TCP-hmac"),
+                                    dh,
+                                    sizeof(*dh),
+                                    pid,
+                                    sizeof(*pid),
+                                    NULL,
+                                    0));
+}
+
+
+/**
+ * Callback called when peerstore store operation for rekey monotime value is finished.
+ * @param cls Queue context the store operation was executed.
+ * @param success Store operation was successful (GNUNET_OK) or not.
+ */
+static void
+rekey_monotime_store_cb (void *cls, int success)
+{
+  struct Queue *queue = cls;
+  if (GNUNET_OK != success)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to store rekey monotonic time in PEERSTORE!\n");
+  }
+  queue->rekey_monotime_sc = NULL;
+  GNUNET_PEERSTORE_iteration_next (queue->rekey_monotime_get, 1);
+}
+
+
+/**
+ * Callback called by peerstore when records for GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_REKEY
+ * where found.
+ * @param cls Queue context the store operation was executed.
+ * @param record The record found or NULL if there is no record left.
+ * @param emsg Message from peerstore.
+ */
+static void
+rekey_monotime_cb (void *cls,
+                   const struct GNUNET_PEERSTORE_Record *record,
+                   const char *emsg)
+{
+  struct Queue *queue = cls;
+  struct GNUNET_TIME_AbsoluteNBO *mtbe;
+  struct GNUNET_TIME_Absolute mt;
+  const struct GNUNET_PeerIdentity *pid;
+  struct GNUNET_TIME_AbsoluteNBO *rekey_monotonic_time;
+
+  (void) emsg;
+
+  rekey_monotonic_time = &queue->rekey_monotonic_time;
+  pid = &queue->target;
+  if (NULL == record)
+  {
+    queue->rekey_monotime_get = NULL;
+    return;
+  }
+  if (sizeof(*mtbe) != record->value_size)
+  {
+    GNUNET_PEERSTORE_iteration_next (queue->rekey_monotime_get, 1);
+    GNUNET_break (0);
+    return;
+  }
+  mtbe = record->value;
+  mt = GNUNET_TIME_absolute_ntoh (*mtbe);
+  if (mt.abs_value_us > GNUNET_TIME_absolute_ntoh (
+        queue->rekey_monotonic_time).abs_value_us)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Queue from %s dropped, rekey monotime in the past\n",
+                GNUNET_i2s (&queue->target));
+    GNUNET_break (0);
+    GNUNET_PEERSTORE_iteration_stop (queue->rekey_monotime_get);
+    queue->rekey_monotime_get = NULL;
+    // FIXME: Why should we try to gracefully finish here??
+    queue_finish (queue);
+    return;
+  }
+  queue->rekey_monotime_sc = GNUNET_PEERSTORE_store (peerstore,
+                                                     "transport_tcp_communicator",
+                                                     pid,
+                                                     GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_REKEY,
+                                                     rekey_monotonic_time,
+                                                     sizeof(*
+                                                            rekey_monotonic_time),
+                                                     GNUNET_TIME_UNIT_FOREVER_ABS,
+                                                     GNUNET_PEERSTORE_STOREOPTION_REPLACE,
+                                                     &rekey_monotime_store_cb,
+                                                     queue);
+}
+
+
+/**
+ * Setup cipher of @a queue for decryption.
+ *
+ * @param ephemeral ephemeral key we received from the other peer
+ * @param[in,out] queue queue to initialize decryption cipher for
+ */
+static void
+setup_in_cipher (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral,
+                 struct Queue *queue)
+{
+  struct GNUNET_HashCode k;
+
+  GNUNET_CRYPTO_eddsa_kem_decaps (my_private_key, ephemeral, &k);
+  setup_cipher (&k, &my_identity, &queue->in_cipher, &queue->in_hmac);
+}
+
+
+/**
+ * Handle @a rekey message on @a queue. The message was already
+ * HMAC'ed, but we should additionally still check the signature.
+ * Then we need to stop the old cipher and start afresh.
+ *
+ * @param queue the queue @a rekey was received on
+ * @param rekey the rekey message
+ */
+static void
+do_rekey (struct Queue *queue, const struct TCPRekey *rekey)
+{
+  struct TcpRekeySignature thp;
+
+  thp.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_REKEY);
+  thp.purpose.size = htonl (sizeof(thp));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "do_rekey size %u\n",
+              thp.purpose.size);
+  thp.sender = queue->target;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "sender %s\n",
+              GNUNET_p2s (&thp.sender.public_key));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "sender %s\n",
+              GNUNET_p2s (&queue->target.public_key));
+  thp.receiver = my_identity;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "receiver %s\n",
+              GNUNET_p2s (&thp.receiver.public_key));
+  thp.ephemeral = rekey->ephemeral;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "ephemeral %s\n",
+              GNUNET_e2s (&thp.ephemeral));
+  thp.monotonic_time = rekey->monotonic_time;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "time %s\n",
+              GNUNET_STRINGS_absolute_time_to_string (
+                GNUNET_TIME_absolute_ntoh (thp.monotonic_time)));
+  GNUNET_assert (ntohl ((&thp)->purpose.size) == sizeof (*(&thp)));
+  if (GNUNET_OK !=
+      GNUNET_CRYPTO_eddsa_verify (
+        GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_REKEY,
+        &thp,
+        &rekey->sender_sig,
+        &queue->target.public_key))
+  {
+    GNUNET_break (0);
+    // FIXME Why should we try to gracefully finish here?
+    queue_finish (queue);
+    return;
+  }
+  queue->rekey_monotonic_time = rekey->monotonic_time;
+  queue->rekey_monotime_get = GNUNET_PEERSTORE_iteration_start (peerstore,
+                                                                "transport_tcp_communicator",
+                                                                &queue->target,
+                                                                GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_REKEY,
+                                                                &
+                                                                rekey_monotime_cb,
+                                                                queue);
+  gcry_cipher_close (queue->in_cipher);
+  queue->rekeyed = GNUNET_YES;
+  setup_in_cipher (&rekey->ephemeral, queue);
+}
+
+
+/**
+ * Callback called when peerstore store operation for handshake ack monotime value is finished.
+ * @param cls Queue context the store operation was executed.
+ * @param success Store operation was successful (GNUNET_OK) or not.
+ */
+static void
+handshake_ack_monotime_store_cb (void *cls, int success)
+{
+  struct Queue *queue = cls;
+
+  if (GNUNET_OK != success)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to store handshake ack monotonic time in PEERSTORE!\n");
+  }
+  queue->handshake_ack_monotime_sc = NULL;
+  GNUNET_PEERSTORE_iteration_next (queue->handshake_ack_monotime_get, 1);
+}
+
+
+/**
+ * Callback called by peerstore when records for GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE_ACK
+ * where found.
+ * @param cls Queue context the store operation was executed.
+ * @param record The record found or NULL if there is no record left.
+ * @param emsg Message from peerstore.
+ */
+static void
+handshake_ack_monotime_cb (void *cls,
+                           const struct GNUNET_PEERSTORE_Record *record,
+                           const char *emsg)
+{
+  struct Queue *queue = cls;
+  struct GNUNET_TIME_AbsoluteNBO *mtbe;
+  struct GNUNET_TIME_Absolute mt;
+  const struct GNUNET_PeerIdentity *pid;
+  struct GNUNET_TIME_AbsoluteNBO *handshake_ack_monotonic_time;
+
+  (void) emsg;
+
+  handshake_ack_monotonic_time = &queue->handshake_ack_monotonic_time;
+  pid = &queue->target;
+  if (NULL == record)
+  {
+    queue->handshake_ack_monotime_get = NULL;
+    return;
+  }
+  if (sizeof(*mtbe) != record->value_size)
+  {
+    GNUNET_PEERSTORE_iteration_next (queue->handshake_ack_monotime_get, 1);
+    GNUNET_break (0);
+    return;
+  }
+  mtbe = record->value;
+  mt = GNUNET_TIME_absolute_ntoh (*mtbe);
+  if (mt.abs_value_us > GNUNET_TIME_absolute_ntoh (
+        queue->handshake_ack_monotonic_time).abs_value_us)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Queue from %s dropped, handshake ack monotime in the past\n",
+                GNUNET_i2s (&queue->target));
+    GNUNET_break (0);
+    GNUNET_PEERSTORE_iteration_stop (queue->handshake_ack_monotime_get);
+    queue->handshake_ack_monotime_get = NULL;
+    // FIXME: Why should we try to gracefully finish here?
+    queue_finish (queue);
+    return;
+  }
+  queue->handshake_ack_monotime_sc =
+    GNUNET_PEERSTORE_store (peerstore,
+                            "transport_tcp_communicator",
+                            pid,
+                            GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE_ACK,
+                            handshake_ack_monotonic_time,
+                            sizeof(*handshake_ack_monotonic_time),
+                            GNUNET_TIME_UNIT_FOREVER_ABS,
+                            GNUNET_PEERSTORE_STOREOPTION_REPLACE,
+                            &handshake_ack_monotime_store_cb,
+                            queue);
+}
+
+
+/**
+ * Sending challenge with TcpConfirmationAck back to sender of ephemeral key.
+ *
+ * @param tc The TCPConfirmation originally send.
+ * @param queue The queue context.
+ */
+static void
+send_challenge (struct GNUNET_CRYPTO_ChallengeNonceP challenge,
+                struct Queue *queue)
+{
+  struct TCPConfirmationAck tca;
+  struct TcpHandshakeAckSignature thas;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "sending challenge\n");
+
+  tca.header.type = ntohs (
+    GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_CONFIRMATION_ACK);
+  tca.header.size = ntohs (sizeof(tca));
+  tca.challenge = challenge;
+  tca.sender = my_identity;
+  tca.monotonic_time =
+    GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg));
+  thas.purpose.purpose = htonl (
+    GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_HANDSHAKE_ACK);
+  thas.purpose.size = htonl (sizeof(thas));
+  thas.sender = my_identity;
+  thas.receiver = queue->target;
+  thas.monotonic_time = tca.monotonic_time;
+  thas.challenge = tca.challenge;
+  GNUNET_CRYPTO_eddsa_sign (my_private_key,
+                            &thas,
+                            &tca.sender_sig);
+  GNUNET_assert (0 ==
+                 gcry_cipher_encrypt (queue->out_cipher,
+                                      &queue->cwrite_buf[queue->cwrite_off],
+                                      sizeof(tca),
+                                      &tca,
+                                      sizeof(tca)));
+  queue->cwrite_off += sizeof(tca);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "sending challenge done\n");
+}
+
+
+/**
+ * Setup cipher for outgoing data stream based on target and
+ * our ephemeral private key.
+ *
+ * @param queue queue to setup outgoing (encryption) cipher for
+ */
+static void
+setup_out_cipher (struct Queue *queue, struct GNUNET_HashCode *dh)
+{
+  setup_cipher (dh, &queue->target, &queue->out_cipher, &queue->out_hmac);
+  queue->rekey_time = GNUNET_TIME_relative_to_absolute (rekey_interval);
+  queue->rekey_left_bytes =
+    GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, rekey_max_bytes);
+}
+
+
+/**
+ * Inject a `struct TCPRekey` message into the queue's plaintext
+ * buffer.
+ *
+ * @param queue queue to perform rekeying on
+ */
+static void
+inject_rekey (struct Queue *queue)
+{
+  struct TCPRekey rekey;
+  struct TcpRekeySignature thp;
+  struct GNUNET_HashCode k;
+
+  GNUNET_assert (0 == queue->pwrite_off);
+  memset (&rekey, 0, sizeof(rekey));
+  GNUNET_CRYPTO_eddsa_kem_encaps (&queue->target.public_key, &rekey.ephemeral,
+                                  &k);
+  rekey.header.type = ntohs (GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY);
+  rekey.header.size = ntohs (sizeof(rekey));
+  rekey.monotonic_time =
+    GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg));
+  thp.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_REKEY);
+  thp.purpose.size = htonl (sizeof(thp));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "inject_rekey size %u\n",
+              thp.purpose.size);
+  thp.sender = my_identity;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "sender %s\n",
+              GNUNET_p2s (&thp.sender.public_key));
+  thp.receiver = queue->target;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "receiver %s\n",
+              GNUNET_p2s (&thp.receiver.public_key));
+  thp.ephemeral = rekey.ephemeral;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "ephemeral %s\n",
+              GNUNET_e2s (&thp.ephemeral));
+  thp.monotonic_time = rekey.monotonic_time;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "time %s\n",
+              GNUNET_STRINGS_absolute_time_to_string (
+                GNUNET_TIME_absolute_ntoh (thp.monotonic_time)));
+  GNUNET_CRYPTO_eddsa_sign (my_private_key,
+                            &thp,
+                            &rekey.sender_sig);
+  calculate_hmac (&queue->out_hmac, &rekey, sizeof(rekey), &rekey.hmac);
+  /* Encrypt rekey message with 'old' cipher */
+  GNUNET_assert (0 ==
+                 gcry_cipher_encrypt (queue->out_cipher,
+                                      &queue->cwrite_buf[queue->cwrite_off],
+                                      sizeof(rekey),
+                                      &rekey,
+                                      sizeof(rekey)));
+  queue->cwrite_off += sizeof(rekey);
+  /* Setup new cipher for successive messages */
+  gcry_cipher_close (queue->out_cipher);
+  setup_out_cipher (queue, &k);
+}
+
+
+static int
+pending_reversals_delete_it (void *cls,
+                             const struct GNUNET_HashCode *key,
+                             void *value)
+{
+  (void) cls;
+  struct PendingReversal *pending_reversal = value;
+
+  if (NULL != pending_reversal->timeout_task)
+  {
+    GNUNET_SCHEDULER_cancel (pending_reversal->timeout_task);
+    pending_reversal->timeout_task = NULL;
+  }
+  GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (
+                   pending_reversals,
+                   key,
+                   pending_reversal));
+  GNUNET_free (pending_reversal->in);
+  GNUNET_free (pending_reversal);
+  return GNUNET_OK;
+}
+
+
+static void
+check_and_remove_pending_reversal (struct sockaddr *in, sa_family_t sa_family,
+                                   struct GNUNET_PeerIdentity *sender)
+{
+  if (AF_INET == sa_family)
+  {
+    struct PendingReversal *pending_reversal;
+    struct GNUNET_HashCode key;
+    struct sockaddr_in *natted_address;
+
+    natted_address = GNUNET_memdup (in, sizeof (struct sockaddr));
+    natted_address->sin_port = 0;
+    GNUNET_CRYPTO_hash (natted_address,
+                        sizeof(struct sockaddr),
+                        &key);
+
+    pending_reversal = GNUNET_CONTAINER_multihashmap_get (pending_reversals,
+                                                          &key);
+    if (NULL != pending_reversal && (NULL == sender ||
+                                     0 != memcmp (sender,
+                                                  &pending_reversal->target,
+                                                  sizeof(struct
+                                                         GNUNET_PeerIdentity))))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Removing invalid pending reversal for `%s'at `%s'\n",
+                  GNUNET_i2s (&pending_reversal->target),
+                  GNUNET_a2s (in, sizeof (struct sockaddr)));
+      pending_reversals_delete_it (NULL, &key, pending_reversal);
+    }
+    GNUNET_free (natted_address);
+  }
+}
+
+
+/**
+ * Closes socket and frees memory associated with @a pq.
+ *
+ * @param pq proto queue to free
+ */
+static void
+free_proto_queue (struct ProtoQueue *pq)
+{
+  if (NULL != pq->listen_sock)
+  {
+    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (pq->listen_sock));
+    pq->listen_sock = NULL;
+  }
+  if (NULL != pq->read_task)
+  {
+    GNUNET_SCHEDULER_cancel (pq->read_task);
+    pq->read_task = NULL;
+  }
+  if (NULL != pq->write_task)
+  {
+    GNUNET_SCHEDULER_cancel (pq->write_task);
+    pq->write_task = NULL;
+  }
+  check_and_remove_pending_reversal (pq->address, pq->address->sa_family, NULL);
+  GNUNET_NETWORK_socket_close (pq->sock);
+  GNUNET_free (pq->address);
+  GNUNET_CONTAINER_DLL_remove (proto_head, proto_tail, pq);
+  GNUNET_free (pq);
+}
+
+
+/**
+ * We have been notified that our socket is ready to write.
+ * Then reschedule this function to be called again once more is available.
+ *
+ * @param cls a `struct ProtoQueue`
+ */
+static void
+proto_queue_write (void *cls)
+{
+  struct ProtoQueue *pq = cls;
+  ssize_t sent;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "In proto queue write\n");
+  pq->write_task = NULL;
+  if (0 != pq->write_off)
+  {
+    sent = GNUNET_NETWORK_socket_send (pq->sock,
+                                       pq->write_buf,
+                                       pq->write_off);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sent %lu bytes to TCP queue\n", sent);
+    if ((-1 == sent) && (EAGAIN != errno) && (EINTR != errno))
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send");
+      free_proto_queue (pq);
+      return;
+    }
+    if (sent > 0)
+    {
+      size_t usent = (size_t) sent;
+      pq->write_off -= usent;
+      memmove (pq->write_buf,
+               &pq->write_buf[usent],
+               pq->write_off);
+    }
+  }
+  /* do we care to write more? */
+  if ((0 < pq->write_off))
+    pq->write_task =
+      GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                      pq->sock,
+                                      &proto_queue_write,
+                                      pq);
+}
+
+
+/**
+ * We have been notified that our socket is ready to write.
+ * Then reschedule this function to be called again once more is available.
+ *
+ * @param cls a `struct Queue`
+ */
+static void
+queue_write (void *cls)
+{
+  struct Queue *queue = cls;
+  ssize_t sent;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "In queue write\n");
+  queue->write_task = NULL;
+  if (0 != queue->cwrite_off)
+  {
+    sent = GNUNET_NETWORK_socket_send (queue->sock,
+                                       queue->cwrite_buf,
+                                       queue->cwrite_off);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sent %lu bytes to TCP queue\n", sent);
+    if ((-1 == sent) && (EAGAIN != errno) && (EINTR != errno))
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send");
+      queue_destroy (queue);
+      return;
+    }
+    if (sent > 0)
+    {
+      size_t usent = (size_t) sent;
+      queue->cwrite_off -= usent;
+      memmove (queue->cwrite_buf,
+               &queue->cwrite_buf[usent],
+               queue->cwrite_off);
+      queue->timeout =
+        GNUNET_TIME_relative_to_absolute (
+          GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+    }
+  }
+  /* can we encrypt more? (always encrypt full messages, needed
+     such that #mq_cancel() can work!) */
+  unsigned int we_do_not_need_to_rekey = (0 < queue->rekey_left_bytes
+                                          - (queue->cwrite_off
+                                             + queue->pwrite_off
+                                             + sizeof (struct TCPRekey)));
+  if (we_do_not_need_to_rekey &&
+      (queue->pwrite_off > 0) &&
+      (queue->cwrite_off + queue->pwrite_off <= BUF_SIZE))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Encrypting %lu bytes\n", queue->pwrite_off);
+    GNUNET_assert (0 ==
+                   gcry_cipher_encrypt (queue->out_cipher,
+                                        &queue->cwrite_buf[queue->cwrite_off],
+                                        queue->pwrite_off,
+                                        queue->pwrite_buf,
+                                        queue->pwrite_off));
+    if (queue->rekey_left_bytes > queue->pwrite_off)
+      queue->rekey_left_bytes -= queue->pwrite_off;
+    else
+      queue->rekey_left_bytes = 0;
+    queue->cwrite_off += queue->pwrite_off;
+    queue->pwrite_off = 0;
+  }
+  // if ((-1 != unverified_size)&& ((0 == queue->pwrite_off) &&
+  if (((0 == queue->rekey_left_bytes) ||
+       (0 == GNUNET_TIME_absolute_get_remaining (
+          queue->rekey_time).rel_value_us)) &&
+      (((0 == queue->pwrite_off) || ! we_do_not_need_to_rekey) &&
+       (queue->cwrite_off + sizeof (struct TCPRekey) <= BUF_SIZE)))
+  {
+    inject_rekey (queue);
+  }
+  if ((0 == queue->pwrite_off) && (! queue->finishing) &&
+      (GNUNET_YES == queue->mq_awaits_continue))
+  {
+    queue->mq_awaits_continue = GNUNET_NO;
+    GNUNET_MQ_impl_send_continue (queue->mq);
+  }
+  /* did we just finish writing 'finish'? */
+  if ((0 == queue->cwrite_off) && (GNUNET_YES == queue->finishing))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Finishing queue\n");
+    queue_destroy (queue);
+    return;
+  }
+  /* do we care to write more? */
+  if ((0 < queue->cwrite_off) || (0 < queue->pwrite_off))
+    queue->write_task =
+      GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                      queue->sock,
+                                      &queue_write,
+                                      queue);
+}
+
+
+/**
+ * Test if we have received a full message in plaintext.
+ * If so, handle it.
+ *
+ * @param queue queue to process inbound plaintext for
+ * @return number of bytes of plaintext handled, 0 for none
+ */
+static size_t
+try_handle_plaintext (struct Queue *queue)
+{
+  const struct GNUNET_MessageHeader *hdr;
+  const struct TCPConfirmationAck *tca;
+  const struct TCPBox *box;
+  const struct TCPRekey *rekey;
+  const struct TCPFinish *fin;
+  struct TCPRekey rekeyz;
+  struct TCPFinish finz;
+  struct GNUNET_ShortHashCode tmac;
+  uint16_t type;
+  size_t size = 0;
+  struct TcpHandshakeAckSignature thas;
+  const struct GNUNET_CRYPTO_ChallengeNonceP challenge = queue->challenge;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "try handle plaintext!\n");
+
+  hdr = (const struct GNUNET_MessageHeader *) queue->pread_buf;
+  if ((sizeof(*hdr) > queue->pread_off))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Handling plaintext, not even a header!\n");
+    return 0; /* not even a header */
+  }
+
+  if ((GNUNET_YES != queue->initial_core_kx_done) && (queue->unverified_size >
+                                                      INITIAL_CORE_KX_SIZE))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Already received data of size %lu bigger than KX size %lu!\n",
+                queue->unverified_size,
+                INITIAL_CORE_KX_SIZE);
+    GNUNET_break_op (0);
+    queue_finish (queue);
+    return 0;
+  }
+
+  type = ntohs (hdr->type);
+  switch (type)
+  {
+  case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_CONFIRMATION_ACK:
+    tca = (const struct TCPConfirmationAck *) queue->pread_buf;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "start processing ack\n");
+    if (sizeof(*tca) > queue->pread_off)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Handling plaintext size of tca greater than pread offset.\n")
+      ;
+      return 0;
+    }
+    if (ntohs (hdr->size) != sizeof(*tca))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Handling plaintext size does not match message type.\n");
+      GNUNET_break_op (0);
+      queue_finish (queue);
+      return 0;
+    }
+
+    thas.purpose.purpose = htonl (
+      GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_HANDSHAKE_ACK);
+    thas.purpose.size = htonl (sizeof(thas));
+    thas.sender = tca->sender;
+    thas.receiver = my_identity;
+    thas.monotonic_time = tca->monotonic_time;
+    thas.challenge = tca->challenge;
+
+    if (GNUNET_SYSERR == GNUNET_CRYPTO_eddsa_verify (
+          GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_HANDSHAKE_ACK,
+          &thas,
+          &tca->sender_sig,
+          &tca->sender.public_key))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Verification of signature failed!\n");
+      GNUNET_break (0);
+      queue_finish (queue);
+      return 0;
+    }
+    if (0 != GNUNET_memcmp (&tca->challenge, &challenge))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Challenge in TCPConfirmationAck not correct!\n");
+      GNUNET_break (0);
+      queue_finish (queue);
+      return 0;
+    }
+
+    queue->handshake_ack_monotime_get = GNUNET_PEERSTORE_iteration_start (
+      peerstore,
+      "transport_tcp_communicator",
+      &queue->target,
+      GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE_ACK,
+      &handshake_ack_monotime_cb,
+      queue);
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Handling plaintext, ack processed!\n");
+
+    if (GNUNET_TRANSPORT_CS_INBOUND ==     queue->cs)
+    {
+      send_challenge (queue->challenge_received, queue);
+      queue->write_task =
+        GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                        queue->sock,
+                                        &queue_write,
+                                        queue);
+    }
+    else if (GNUNET_TRANSPORT_CS_OUTBOUND ==     queue->cs)
+    {
+      check_and_remove_pending_reversal (queue->address,
+                                         queue->address->sa_family, NULL);
+    }
+
+    /**
+     * Once we received this ack, we consider this a verified connection.
+     * FIXME: I am not sure this logic is sane here.
+     */
+    queue->initial_core_kx_done = GNUNET_YES;
+
+    char *foreign_addr;
+
+    switch (queue->address->sa_family)
+    {
+    case AF_INET:
+      GNUNET_asprintf (&foreign_addr,
+                       "%s-%s",
+                       COMMUNICATOR_ADDRESS_PREFIX,
+                       GNUNET_a2s (queue->address, queue->address_len));
+      break;
+
+    case AF_INET6:
+      GNUNET_asprintf (&foreign_addr,
+                       "%s-%s",
+                       COMMUNICATOR_ADDRESS_PREFIX,
+                       GNUNET_a2s (queue->address, queue->address_len));
+      break;
+
+    default:
+      GNUNET_assert (0);
+    }
+
+    queue->qh = GNUNET_TRANSPORT_communicator_mq_add (ch,
+                                                      &queue->target,
+                                                      foreign_addr,
+                                                      UINT16_MAX, /* no MTU */
+                                                      GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED,
+                                                      0, /* Priority */
+                                                      queue->nt,
+                                                      queue->cs,
+                                                      queue->mq);
+
+    GNUNET_free (foreign_addr);
+
+    size = ntohs (hdr->size);
+    break;
+  case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX:
+    /* Special case: header size excludes box itself! */
+    box = (const struct TCPBox *) queue->pread_buf;
+    if (ntohs (hdr->size) + sizeof(struct TCPBox) > queue->pread_off)
+      return 0;
+    calculate_hmac (&queue->in_hmac, &box[1], ntohs (hdr->size), &tmac);
+    if (0 != memcmp (&tmac, &box->hmac, sizeof(tmac)))
+    {
+      GNUNET_break_op (0);
+      queue_finish (queue);
+      return 0;
+    }
+    pass_plaintext_to_core (queue, (const void *) &box[1], ntohs (hdr->size));
+    size = ntohs (hdr->size) + sizeof(*box);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Handling plaintext, box processed!\n");
+    GNUNET_STATISTICS_update (stats,
+                              "# bytes decrypted with BOX",
+                              size,
+                              GNUNET_NO);
+    GNUNET_STATISTICS_update (stats,
+                              "# messages decrypted with BOX",
+                              1,
+                              GNUNET_NO);
+    break;
+
+  case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY:
+    rekey = (const struct TCPRekey *) queue->pread_buf;
+    if (sizeof(*rekey) > queue->pread_off)
+      return 0;
+    if (ntohs (hdr->size) != sizeof(*rekey))
+    {
+      GNUNET_break_op (0);
+      queue_finish (queue);
+      return 0;
+    }
+    rekeyz = *rekey;
+    memset (&rekeyz.hmac, 0, sizeof(rekeyz.hmac));
+    calculate_hmac (&queue->in_hmac, &rekeyz, sizeof(rekeyz), &tmac);
+    if (0 != memcmp (&tmac, &rekey->hmac, sizeof(tmac)))
+    {
+      GNUNET_break_op (0);
+      queue_finish (queue);
+      return 0;
+    }
+    do_rekey (queue, rekey);
+    size = ntohs (hdr->size);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Handling plaintext, rekey processed!\n");
+    GNUNET_STATISTICS_update (stats,
+                              "# rekeying successful",
+                              1,
+                              GNUNET_NO);
+    break;
+
+  case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH:
+    fin = (const struct TCPFinish *) queue->pread_buf;
+    if (sizeof(*fin) > queue->pread_off)
+      return 0;
+    if (ntohs (hdr->size) != sizeof(*fin))
+    {
+      GNUNET_break_op (0);
+      queue_finish (queue);
+      return 0;
+    }
+    finz = *fin;
+    memset (&finz.hmac, 0, sizeof(finz.hmac));
+    calculate_hmac (&queue->in_hmac, &finz, sizeof(finz), &tmac);
+    if (0 != memcmp (&tmac, &fin->hmac, sizeof(tmac)))
+    {
+      GNUNET_break_op (0);
+      queue_finish (queue);
+      return 0;
+    }
+    /* handle FINISH by destroying queue */
+    queue_destroy (queue);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Handling plaintext, finish processed!\n");
+    break;
+
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Handling plaintext, nothing processed!\n");
+    GNUNET_break_op (0);
+    queue_finish (queue);
+    return 0;
+  }
+  GNUNET_assert (0 != size);
+  if (-1 != queue->unverified_size)
+    queue->unverified_size += size;
+  return size;
+}
+
+
+/**
+ * Queue read task. If we hit the timeout, disconnect it
+ *
+ * @param cls the `struct Queue *` to disconnect
+ */
+static void
+queue_read (void *cls)
+{
+  struct Queue *queue = cls;
+  struct GNUNET_TIME_Relative left;
+  ssize_t rcvd;
+
+  queue->read_task = NULL;
+  rcvd = GNUNET_NETWORK_socket_recv (queue->sock,
+                                     &queue->cread_buf[queue->cread_off],
+                                     BUF_SIZE - queue->cread_off);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received %zd bytes from TCP queue\n", rcvd);
+  if (-1 == rcvd)
+  {
+    if ((EAGAIN != errno) && (EINTR != errno))
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "recv");
+      queue_destroy (queue);
+      return;
+    }
+    /* try again */
+    left = GNUNET_TIME_absolute_get_remaining (queue->timeout);
+    if (0 != left.rel_value_us)
+    {
+      queue->read_task =
+        GNUNET_SCHEDULER_add_read_net (left, queue->sock, &queue_read, queue);
+      return;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Queue %p was idle for %s, disconnecting\n",
+                queue,
+                GNUNET_STRINGS_relative_time_to_string (
+                  GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+                  GNUNET_YES));
+    queue_destroy (queue);
+    return;
+  }
+  if (0 == rcvd)
+  {
+    /* Orderly shutdown of connection */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Socket for queue %p seems to have been closed\n", queue);
+    queue_destroy (queue);
+    return;
+  }
+  queue->timeout =
+    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+  queue->cread_off += rcvd;
+  while ((queue->pread_off < sizeof(queue->pread_buf)) &&
+         (queue->cread_off > 0))
+  {
+    size_t max = GNUNET_MIN (sizeof(queue->pread_buf) - queue->pread_off,
+                             queue->cread_off);
+    size_t done;
+    size_t total;
+    size_t old_pread_off = queue->pread_off;
+
+    GNUNET_assert (0 ==
+                   gcry_cipher_decrypt (queue->in_cipher,
+                                        &queue->pread_buf[queue->pread_off],
+                                        max,
+                                        queue->cread_buf,
+                                        max));
+    queue->pread_off += max;
+    total = 0;
+    while (0 != (done = try_handle_plaintext (queue)))
+    {
+      /* 'done' bytes of plaintext were used, shift buffer */
+      GNUNET_assert (done <= queue->pread_off);
+      /* NOTE: this memmove() could possibly sometimes be
+         avoided if we pass 'total' into try_handle_plaintext()
+         and use it at an offset into the buffer there! */
+      memmove (queue->pread_buf,
+               &queue->pread_buf[done],
+               queue->pread_off - done);
+      queue->pread_off -= done;
+      total += done;
+      /* The last plaintext was a rekey, abort for now */
+      if (GNUNET_YES == queue->rekeyed)
+        break;
+    }
+    /* when we encounter a rekey message, the decryption above uses the
+       wrong key for everything after the rekey; in that case, we have
+       to re-do the decryption at 'total' instead of at 'max'.
+       However, we have to take into account that the plaintext buffer may have
+       already contained data and not jumped too far ahead in the ciphertext.
+       If there is no rekey and the last message is incomplete (max > total),
+       it is safe to keep the decryption so we shift by 'max' */
+    if (GNUNET_YES == queue->rekeyed)
+    {
+      max = total - old_pread_off;
+      queue->rekeyed = GNUNET_NO;
+      queue->pread_off = 0;
+    }
+    memmove (queue->cread_buf, &queue->cread_buf[max], queue->cread_off - max);
+    queue->cread_off -= max;
+  }
+  if (BUF_SIZE == queue->cread_off)
+    return; /* buffer full, suspend reading */
+  left = GNUNET_TIME_absolute_get_remaining (queue->timeout);
+  if (0 != left.rel_value_us)
+  {
+    if (max_queue_length > queue->backpressure)
+    {
+      /* continue reading */
+      queue->read_task =
+        GNUNET_SCHEDULER_add_read_net (left, queue->sock, &queue_read, queue);
+    }
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Queue %p was idle for %s, disconnecting\n",
+              queue,
+              GNUNET_STRINGS_relative_time_to_string (
+                GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+                GNUNET_YES));
+  queue_destroy (queue);
+}
+
+
+/**
+ * Convert a `struct sockaddr_in6 to a `struct sockaddr *`
+ *
+ * @param[out] sock_len set to the length of the address.
+ * @param v6 The sockaddr_in6 to be converted.
+ * @return The struct sockaddr *.
+ */
+static struct sockaddr *
+tcp_address_to_sockaddr_numeric_v6 (socklen_t *sock_len,
+                                    struct sockaddr_in6 v6,
+                                    unsigned int port)
+{
+  struct sockaddr *in;
+
+  v6.sin6_family = AF_INET6;
+  v6.sin6_port = htons ((uint16_t) port);
+#if HAVE_SOCKADDR_IN_SIN_LEN
+  v6.sin6_len = sizeof(struct sockaddr_in6);
+#endif
+  v6.sin6_flowinfo = 0;
+  v6.sin6_scope_id = 0;
+  in = GNUNET_memdup (&v6, sizeof(v6));
+  *sock_len = sizeof(struct sockaddr_in6);
+
+  return in;
+}
+
+
+/**
+ * Convert a `struct sockaddr_in4 to a `struct sockaddr *`
+ *
+ * @param[out] sock_len set to the length of the address.
+ * @param v4 The sockaddr_in4 to be converted.
+ * @return The struct sockaddr *.
+ */
+static struct sockaddr *
+tcp_address_to_sockaddr_numeric_v4 (socklen_t *sock_len,
+                                    struct sockaddr_in v4,
+                                    unsigned int port)
+{
+  struct sockaddr *in;
+
+  v4.sin_family = AF_INET;
+  v4.sin_port = htons ((uint16_t) port);
+#if HAVE_SOCKADDR_IN_SIN_LEN
+  v4.sin_len = sizeof(struct sockaddr_in);
+#endif
+  in = GNUNET_memdup (&v4, sizeof(v4));
+  *sock_len = sizeof(struct sockaddr_in);
+  return in;
+}
+
+
+/**
+ * Convert TCP bind specification to a `struct PortOnlyIpv4Ipv6  *`
+ *
+ * @param bindto bind specification to convert.
+ * @return The converted bindto specification.
+ */
+static struct PortOnlyIpv4Ipv6 *
+tcp_address_to_sockaddr_port_only (const char *bindto, unsigned int *port)
+{
+  struct PortOnlyIpv4Ipv6 *po;
+  struct sockaddr_in *i4;
+  struct sockaddr_in6 *i6;
+  socklen_t sock_len_ipv4;
+  socklen_t sock_len_ipv6;
+
+  /* interpreting value as just a PORT number */
+  if (*port > UINT16_MAX)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "BINDTO specification `%s' invalid: value too large for port\n",
+                bindto);
+    return NULL;
+  }
+
+  po = GNUNET_new (struct PortOnlyIpv4Ipv6);
+
+  if (GNUNET_YES == disable_v6)
+  {
+    i4 = GNUNET_malloc (sizeof(struct sockaddr_in));
+    po->addr_ipv4 = tcp_address_to_sockaddr_numeric_v4 (&sock_len_ipv4, *i4,
+                                                        *port);
+    po->addr_len_ipv4 = sock_len_ipv4;
+  }
+  else
+  {
+
+    i4 = GNUNET_malloc (sizeof(struct sockaddr_in));
+    po->addr_ipv4 = tcp_address_to_sockaddr_numeric_v4 (&sock_len_ipv4, *i4,
+                                                        *port);
+    po->addr_len_ipv4 = sock_len_ipv4;
+
+    i6 = GNUNET_malloc (sizeof(struct sockaddr_in6));
+    po->addr_ipv6 = tcp_address_to_sockaddr_numeric_v6 (&sock_len_ipv6, *i6,
+                                                        *port);
+
+    po->addr_len_ipv6 = sock_len_ipv6;
+
+    GNUNET_free (i6);
+  }
+
+  GNUNET_free (i4);
+
+  return po;
+}
+
+
+/**
+ * This Method extracts the address part of the BINDTO string.
+ *
+ * @param bindto String we extract the address part from.
+ * @return The extracted address string.
+ */
+static char *
+extract_address (const char *bindto)
+{
+  char *addr;
+  char *start;
+  char *token;
+  char *cp;
+  char *rest = NULL;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "extract address with bindto %s\n",
+              bindto);
+
+  if (NULL == bindto)
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "bindto is NULL\n");
+
+  cp = GNUNET_strdup (bindto);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "extract address 2\n");
+
+  start = cp;
+  if (('[' == *cp) && (']' == cp[strlen (cp) - 1]))
+  {
+    start++;   /* skip over '['*/
+    cp[strlen (cp) - 1] = '\0';  /* eat ']'*/
+    addr = GNUNET_strdup (start);
+  }
+  else
+  {
+    token = strtok_r (cp, "]", &rest);
+    if (strlen (bindto) == strlen (token))
+    {
+      token = strtok_r (cp, ":", &rest);
+      addr = GNUNET_strdup (token);
+    }
+    else
+    {
+      token++;
+      addr = GNUNET_strdup (token);
+    }
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "tcp address: %s\n",
+              addr);
+  GNUNET_free (cp);
+  return addr;
+}
+
+
+/**
+ * This Method extracts the port part of the BINDTO string.
+ *
+ * @param addr_and_port String we extract the port from.
+ * @return The extracted port as unsigned int.
+ */
+static unsigned int
+extract_port (const char *addr_and_port)
+{
+  unsigned int port;
+  char dummy[2];
+  char *token;
+  char *addr;
+  char *colon;
+  char *cp;
+  char *rest = NULL;
+
+  if (NULL != addr_and_port)
+  {
+    cp = GNUNET_strdup (addr_and_port);
+    token = strtok_r (cp, "]", &rest);
+    if (strlen (addr_and_port) == strlen (token))
+    {
+      colon = strrchr (cp, ':');
+      if (NULL == colon)
+      {
+        GNUNET_free (cp);
+        return 0;
+      }
+      addr = colon;
+      addr++;
+    }
+    else
+    {
+      token = strtok_r (NULL, "]", &rest);
+      if (NULL == token)
+      {
+        GNUNET_free (cp);
+        return 0;
+      }
+      else
+      {
+        addr = token;
+        addr++;
+      }
+    }
+
+
+    if (1 == sscanf (addr, "%u%1s", &port, dummy))
+    {
+      /* interpreting value as just a PORT number */
+      if (port > UINT16_MAX)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "Port `%u' invalid: value too large for port\n",
+                    port);
+        GNUNET_free (cp);
+        return 0;
+      }
+    }
+    else
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "BINDTO specification invalid: last ':' not followed by number\n");
+      GNUNET_free (cp);
+      return 0;
+    }
+    GNUNET_free (cp);
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "return 0\n");
+    /* interpret missing port as 0, aka pick any free one */
+    port = 0;
+  }
+
+  return port;
+}
+
+
+/**
+ * Convert TCP bind specification to a `struct sockaddr *`
+ *
+ * @param bindto bind specification to convert
+ * @param[out] sock_len set to the length of the address
+ * @return converted bindto specification
+ */
+static struct sockaddr *
+tcp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
+{
+  struct sockaddr *in;
+  unsigned int port;
+  struct sockaddr_in v4;
+  struct sockaddr_in6 v6;
+  char *start;
+
+  memset (&v4, 0, sizeof(v4));
+  start = extract_address (bindto);
+  GNUNET_assert (NULL != start);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "start %s\n",
+              start);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "!bindto %s\n",
+              bindto);
+
+
+  if (1 == inet_pton (AF_INET, start, &v4.sin_addr))
+  {
+    port = extract_port (bindto);
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "port %u\n",
+                port);
+
+    in = tcp_address_to_sockaddr_numeric_v4 (sock_len, v4, port);
+  }
+  else if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
+  {
+    port = extract_port (bindto);
+    in = tcp_address_to_sockaddr_numeric_v6 (sock_len, v6, port);
+  }
+  else
+  {
+    GNUNET_assert (0);
+  }
+
+  GNUNET_free (start);
+  return in;
+}
+
+
+/**
+ * Signature of functions implementing the sending functionality of a
+ * message queue.
+ *
+ * @param mq the message queue
+ * @param msg the message to send
+ * @param impl_state our `struct Queue`
+ */
+static void
+mq_send (struct GNUNET_MQ_Handle *mq,
+         const struct GNUNET_MessageHeader *msg,
+         void *impl_state)
+{
+  struct Queue *queue = impl_state;
+  uint16_t msize = ntohs (msg->size);
+  struct TCPBox box;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "In MQ send. Queue finishing: %s; write task running: %s\n",
+              (GNUNET_YES == queue->finishing) ? "yes" : "no",
+              (NULL == queue->write_task) ? "yes" : "no");
+  GNUNET_assert (mq == queue->mq);
+  queue->mq_awaits_continue = GNUNET_YES;
+  if (GNUNET_YES == queue->finishing)
+    return; /* this queue is dying, drop msg */
+  GNUNET_assert (0 == queue->pwrite_off);
+  box.header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX);
+  box.header.size = htons (msize);
+  calculate_hmac (&queue->out_hmac, msg, msize, &box.hmac);
+  memcpy (&queue->pwrite_buf[queue->pwrite_off], &box, sizeof(box));
+  queue->pwrite_off += sizeof(box);
+  memcpy (&queue->pwrite_buf[queue->pwrite_off], msg, msize);
+  queue->pwrite_off += msize;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "%lu bytes of plaintext to send\n", queue->pwrite_off);
+  GNUNET_assert (NULL != queue->sock);
+  if (NULL == queue->write_task)
+    queue->write_task =
+      GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                      queue->sock,
+                                      &queue_write,
+                                      queue);
+}
+
+
+/**
+ * Signature of functions implementing the destruction of a message
+ * queue.  Implementations must not free @a mq, but should take care
+ * of @a impl_state.
+ *
+ * @param mq the message queue to destroy
+ * @param impl_state our `struct Queue`
+ */
+static void
+mq_destroy (struct GNUNET_MQ_Handle *mq, void *impl_state)
+{
+  struct Queue *queue = impl_state;
+
+  if (mq == queue->mq)
+  {
+    queue->mq = NULL;
+    queue_finish (queue);
+  }
+}
+
+
+/**
+ * Implementation function that cancels the currently sent message.
+ *
+ * @param mq message queue
+ * @param impl_state our `struct Queue`
+ */
+static void
+mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
+{
+  struct Queue *queue = impl_state;
+
+  GNUNET_assert (0 != queue->pwrite_off);
+  queue->pwrite_off = 0;
+}
+
+
+/**
+ * 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 our `struct Queue`
+ * @param error error code
+ */
+static void
+mq_error (void *cls, enum GNUNET_MQ_Error error)
+{
+  struct Queue *queue = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "MQ error in queue to %s: %d\n",
+              GNUNET_i2s (&queue->target),
+              (int) error);
+  queue_finish (queue);
+}
+
+
+/**
+ * Add the given @a queue to our internal data structure.  Setup the
+ * MQ processing and inform transport that the queue is ready.  Must
+ * be called after the KX for outgoing messages has been bootstrapped.
+ *
+ * @param queue queue to boot
+ */
+static void
+boot_queue (struct Queue *queue)
+{
+  queue->nt =
+    GNUNET_NT_scanner_get_type (is, queue->address, queue->address_len);
+  (void) GNUNET_CONTAINER_multihashmap_put (
+    queue_map,
+    &queue->key,
+    queue,
+    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  GNUNET_STATISTICS_set (stats,
+                         "# queues active",
+                         GNUNET_CONTAINER_multihashmap_size (queue_map),
+                         GNUNET_NO);
+  queue->timeout =
+    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+  queue->mq = GNUNET_MQ_queue_for_callbacks (&mq_send,
+                                             &mq_destroy,
+                                             &mq_cancel,
+                                             queue,
+                                             NULL,
+                                             &mq_error,
+                                             queue);
+}
+
+
+/**
+ * Generate and transmit our ephemeral key and the signature for
+ * the initial KX with the other peer.  Must be called first, before
+ * any other bytes are ever written to the output buffer.  Note that
+ * our cipher must already be initialized when calling this function.
+ * Helper function for #start_initial_kx_out().
+ *
+ * @param queue queue to do KX for
+ * @param epub our public key for the KX
+ */
+static void
+transmit_kx (struct Queue *queue,
+             const struct GNUNET_CRYPTO_EcdhePublicKey *epub)
+{
+  struct TcpHandshakeSignature ths;
+  struct TCPConfirmation tc;
+
+  memcpy (queue->cwrite_buf, epub, sizeof(*epub));
+  queue->cwrite_off = sizeof(*epub);
+  /* compute 'tc' and append in encrypted format to cwrite_buf */
+  tc.sender = my_identity;
+  tc.monotonic_time =
+    GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg));
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE,
+                              &tc.challenge,
+                              sizeof(tc.challenge));
+  ths.purpose.purpose = htonl (
+    GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_HANDSHAKE);
+  ths.purpose.size = htonl (sizeof(ths));
+  ths.sender = my_identity;
+  ths.receiver = queue->target;
+  ths.ephemeral = *epub;
+  ths.monotonic_time = tc.monotonic_time;
+  ths.challenge = tc.challenge;
+  GNUNET_CRYPTO_eddsa_sign (my_private_key,
+                            &ths,
+                            &tc.sender_sig);
+  GNUNET_assert (0 ==
+                 gcry_cipher_encrypt (queue->out_cipher,
+                                      &queue->cwrite_buf[queue->cwrite_off],
+                                      sizeof(tc),
+                                      &tc,
+                                      sizeof(tc)));
+  queue->challenge = tc.challenge;
+  queue->cwrite_off += sizeof(tc);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "handshake written\n");
+}
+
+
+/**
+ * Initialize our key material for outgoing transmissions and
+ * inform the other peer about it. Must be called first before
+ * any data is sent.
+ *
+ * @param queue the queue to setup
+ */
+static void
+start_initial_kx_out (struct Queue *queue)
+{
+  struct GNUNET_CRYPTO_EcdhePublicKey epub;
+  struct GNUNET_HashCode k;
+
+  // TODO: We could use the Elligator KEM here! https://bugs.gnunet.org/view.php?id=8065
+  GNUNET_CRYPTO_eddsa_kem_encaps (&queue->target.public_key, &epub, &k);
+  setup_out_cipher (queue, &k);
+  transmit_kx (queue, &epub);
+}
+
+
+/**
+ * Callback called when peerstore store operation for handshake monotime is finished.
+ * @param cls Queue context the store operation was executed.
+ * @param success Store operation was successful (GNUNET_OK) or not.
+ */
+static void
+handshake_monotime_store_cb (void *cls, int success)
+{
+  struct Queue *queue = cls;
+  if (GNUNET_OK != success)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to store handshake monotonic time in PEERSTORE!\n");
+  }
+  queue->handshake_monotime_sc = NULL;
+  GNUNET_PEERSTORE_iteration_next (queue->handshake_ack_monotime_get, 1);
+}
+
+
+/**
+ * Callback called by peerstore when records for GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE
+ * where found.
+ * @param cls Queue context the store operation was executed.
+ * @param record The record found or NULL if there is no record left.
+ * @param emsg Message from peerstore.
+ */
+static void
+handshake_monotime_cb (void *cls,
+                       const struct GNUNET_PEERSTORE_Record *record,
+                       const char *emsg)
+{
+  struct Queue *queue = cls;
+  struct GNUNET_TIME_AbsoluteNBO *mtbe;
+  struct GNUNET_TIME_Absolute mt;
+  const struct GNUNET_PeerIdentity *pid;
+  struct GNUNET_TIME_AbsoluteNBO *handshake_monotonic_time;
+
+  (void) emsg;
+
+  handshake_monotonic_time = &queue->handshake_monotonic_time;
+  pid = &queue->target;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "tcp handshake with us %s\n",
+              GNUNET_i2s (&my_identity));
+  if (NULL == record)
+  {
+    queue->handshake_monotime_get = NULL;
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "tcp handshake from peer %s\n",
+              GNUNET_i2s (pid));
+  if (sizeof(*mtbe) != record->value_size)
+  {
+    GNUNET_PEERSTORE_iteration_next (queue->handshake_ack_monotime_get, 1);
+    GNUNET_break (0);
+    return;
+  }
+  mtbe = record->value;
+  mt = GNUNET_TIME_absolute_ntoh (*mtbe);
+  if (mt.abs_value_us > GNUNET_TIME_absolute_ntoh (
+        queue->handshake_monotonic_time).abs_value_us)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Queue from %s dropped, handshake monotime in the past\n",
+                GNUNET_i2s (&queue->target));
+    GNUNET_break (0);
+    GNUNET_PEERSTORE_iteration_stop (queue->handshake_ack_monotime_get);
+    queue->handshake_ack_monotime_get = NULL;
+    queue_finish (queue);
+    return;
+  }
+  queue->handshake_monotime_sc = GNUNET_PEERSTORE_store (peerstore,
+                                                         "transport_tcp_communicator",
+                                                         pid,
+                                                         GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE,
+                                                         handshake_monotonic_time,
+                                                         sizeof(*
+                                                                handshake_monotonic_time),
+                                                         GNUNET_TIME_UNIT_FOREVER_ABS,
+                                                         GNUNET_PEERSTORE_STOREOPTION_REPLACE,
+                                                         &
+                                                         handshake_monotime_store_cb,
+                                                         queue);
+}
+
+
+/**
+ * We have received the first bytes from the other side on a @a queue.
+ * Decrypt the @a tc contained in @a ibuf and check the signature.
+ * Note that #setup_in_cipher() must have already been called.
+ *
+ * @param queue queue to decrypt initial bytes from other peer for
+ * @param[out] tc where to store the result
+ * @param ibuf incoming data, of size
+ *        `INITIAL_KX_SIZE`
+ * @return #GNUNET_OK if the signature was OK, #GNUNET_SYSERR if not
+ */
+static int
+decrypt_and_check_tc (struct Queue *queue,
+                      struct TCPConfirmation *tc,
+                      char *ibuf)
+{
+  struct TcpHandshakeSignature ths;
+  enum GNUNET_GenericReturnValue ret;
+
+  GNUNET_assert (
+    0 ==
+    gcry_cipher_decrypt (queue->in_cipher,
+                         tc,
+                         sizeof(*tc),
+                         &ibuf[sizeof(struct GNUNET_CRYPTO_EcdhePublicKey)],
+                         sizeof(*tc)));
+  ths.purpose.purpose = htonl (
+    GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_HANDSHAKE);
+  ths.purpose.size = htonl (sizeof(ths));
+  ths.sender = tc->sender;
+  ths.receiver = my_identity;
+  memcpy (&ths.ephemeral, ibuf, sizeof(struct GNUNET_CRYPTO_EcdhePublicKey));
+  ths.monotonic_time = tc->monotonic_time;
+  ths.challenge = tc->challenge;
+  ret = GNUNET_CRYPTO_eddsa_verify (
+    GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_HANDSHAKE,
+    &ths,
+    &tc->sender_sig,
+    &tc->sender.public_key);
+  if (GNUNET_YES == ret)
+    queue->handshake_monotime_get =
+      GNUNET_PEERSTORE_iteration_start (peerstore,
+                                        "transport_tcp_communicator",
+                                        &queue->target,
+                                        GNUNET_PEERSTORE_TRANSPORT_TCP_COMMUNICATOR_HANDSHAKE,
+                                        &handshake_monotime_cb,
+                                        queue);
+  return ret;
+}
+
+
+/**
+ * Read from the socket of the queue until we have enough data
+ * to initialize the decryption logic and can switch to regular
+ * reading.
+ *
+ * @param cls a `struct Queue`
+ */
+static void
+queue_read_kx (void *cls)
+{
+  struct Queue *queue = cls;
+  ssize_t rcvd;
+  struct GNUNET_TIME_Relative left;
+  struct TCPConfirmation tc;
+
+  queue->read_task = NULL;
+  left = GNUNET_TIME_absolute_get_remaining (queue->timeout);
+  if (0 == left.rel_value_us)
+  {
+    queue_destroy (queue);
+    return;
+  }
+  rcvd = GNUNET_NETWORK_socket_recv (queue->sock,
+                                     &queue->cread_buf[queue->cread_off],
+                                     BUF_SIZE - queue->cread_off);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received %lu bytes to write in buffer of size %lu for KX from queue %p (expires in %"
+              PRIu64 ")\n",
+              rcvd, BUF_SIZE - queue->cread_off, queue, left.rel_value_us);
+  if (-1 == rcvd)
+  {
+    if ((EAGAIN != errno) && (EINTR != errno))
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "recv");
+      queue_destroy (queue);
+      return;
+    }
+    queue->read_task =
+      GNUNET_SCHEDULER_add_read_net (left, queue->sock, &queue_read_kx, queue);
+    return;
+  }
+  if (0 == rcvd)
+  {
+    /* Orderly shutdown of connection */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Socket for queue %p seems to have been closed\n", queue);
+    queue_destroy (queue);
+    return;
+  }
+  queue->cread_off += rcvd;
+  if (queue->cread_off < INITIAL_KX_SIZE)
+  {
+    /* read more */
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "%lu/%lu bytes of KX read. Rescheduling...\n",
+                queue->cread_off, INITIAL_KX_SIZE);
+    queue->read_task =
+      GNUNET_SCHEDULER_add_read_net (left, queue->sock, &queue_read_kx, queue);
+    return;
+  }
+  /* we got all the data, let's find out who we are talking to! */
+  setup_in_cipher ((const struct GNUNET_CRYPTO_EcdhePublicKey *)
+                   queue->cread_buf,
+                   queue);
+  if (GNUNET_OK != decrypt_and_check_tc (queue, &tc, queue->cread_buf))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Invalid TCP KX received from %s\n",
+                GNUNET_a2s (queue->address, queue->address_len));
+    queue_destroy (queue);
+    return;
+  }
+  if (0 !=
+      memcmp (&tc.sender, &queue->target, sizeof(struct GNUNET_PeerIdentity)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Invalid sender in TCP KX received from %s\n",
+                GNUNET_a2s (queue->address, queue->address_len));
+    queue_destroy (queue);
+    return;
+  }
+  send_challenge (tc.challenge, queue);
+  queue->write_task =
+    GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                    queue->sock,
+                                    &queue_write,
+                                    queue);
+
+  /* update queue timeout */
+  queue->timeout =
+    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+  /* prepare to continue with regular read task immediately */
+  memmove (queue->cread_buf,
+           &queue->cread_buf[INITIAL_KX_SIZE],
+           queue->cread_off - (INITIAL_KX_SIZE));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "cread_off is %lu bytes before adjusting\n",
+              queue->cread_off);
+  queue->cread_off -= INITIAL_KX_SIZE;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "cread_off set to %lu bytes\n",
+              queue->cread_off);
+  queue->read_task = GNUNET_SCHEDULER_add_now (&queue_read, queue);
+}
+
+
+/**
+ * Read from the socket of the proto queue until we have enough data
+ * to upgrade to full queue.
+ *
+ * @param cls a `struct ProtoQueue`
+ */
+static void
+proto_read_kx (void *cls)
+{
+  struct ProtoQueue *pq = cls;
+  ssize_t rcvd;
+  struct GNUNET_TIME_Relative left;
+  struct Queue *queue;
+  struct TCPConfirmation tc;
+  GNUNET_SCHEDULER_TaskCallback read_task;
+
+  pq->read_task = NULL;
+  left = GNUNET_TIME_absolute_get_remaining (pq->timeout);
+  if (0 == left.rel_value_us)
+  {
+    free_proto_queue (pq);
+    return;
+  }
+  rcvd = GNUNET_NETWORK_socket_recv (pq->sock,
+                                     &pq->ibuf[pq->ibuf_off],
+                                     sizeof(pq->ibuf) - pq->ibuf_off);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Proto received %lu bytes for KX\n", rcvd);
+  if (-1 == rcvd)
+  {
+    if ((EAGAIN != errno) && (EINTR != errno))
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "recv");
+      free_proto_queue (pq);
+      return;
+    }
+    /* try again */
+    pq->read_task =
+      GNUNET_SCHEDULER_add_read_net (left, pq->sock, &proto_read_kx, pq);
+    return;
+  }
+  if (0 == rcvd)
+  {
+    /* Orderly shutdown of connection */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Socket for proto queue %p seems to have been closed\n", pq);
+    free_proto_queue (pq);
+    return;
+  }
+  pq->ibuf_off += rcvd;
+  if (sizeof (struct TCPNATProbeMessage) == pq->ibuf_off)
+  {
+    struct TCPNATProbeMessage *pm = (struct TCPNATProbeMessage *) pq->ibuf;
+
+    check_and_remove_pending_reversal (pq->address, pq->address->sa_family,
+                                       &pm->clientIdentity);
+
+    queue = GNUNET_new (struct Queue);
+    queue->target = pm->clientIdentity;
+    queue->cs = GNUNET_TRANSPORT_CS_OUTBOUND;
+    read_task = &queue_read_kx;
+  }
+  else if (pq->ibuf_off > sizeof(pq->ibuf))
+  {
+    /* read more */
+    pq->read_task =
+      GNUNET_SCHEDULER_add_read_net (left, pq->sock, &proto_read_kx, pq);
+    return;
+  }
+  else
+  {
+    /* we got all the data, let's find out who we are talking to! */
+    queue = GNUNET_new (struct Queue);
+    setup_in_cipher ((const struct GNUNET_CRYPTO_EcdhePublicKey *) pq->ibuf,
+                     queue);
+    if (GNUNET_OK != decrypt_and_check_tc (queue, &tc, pq->ibuf))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Invalid TCP KX received from %s\n",
+                  GNUNET_a2s (pq->address, pq->address_len));
+      gcry_cipher_close (queue->in_cipher);
+      GNUNET_free (queue);
+      free_proto_queue (pq);
+      return;
+    }
+    queue->target = tc.sender;
+    queue->cs = GNUNET_TRANSPORT_CS_INBOUND;
+    read_task = &queue_read;
+  }
+  queue->address = pq->address; /* steals reference */
+  queue->address_len = pq->address_len;
+  queue->listen_sock = pq->listen_sock;
+  queue->sock = pq->sock;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "created queue with target %s\n",
+              GNUNET_i2s (&queue->target));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "start kx proto\n");
+
+  start_initial_kx_out (queue);
+  boot_queue (queue);
+  queue->read_task =
+    GNUNET_SCHEDULER_add_read_net (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+                                   queue->sock,
+                                   read_task,
+                                   queue);
+  queue->write_task =
+    GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                    queue->sock,
+                                    &queue_write,
+                                    queue);
+  // TODO To early! Move it somewhere else.
+  // send_challenge (tc.challenge, queue);
+  queue->challenge_received = tc.challenge;
+
+  GNUNET_CONTAINER_DLL_remove (proto_head, proto_tail, pq);
+  GNUNET_free (pq);
+}
+
+
+static struct ProtoQueue *
+create_proto_queue (struct GNUNET_NETWORK_Handle *sock,
+                    struct sockaddr *in,
+                    socklen_t addrlen)
+{
+  struct ProtoQueue *pq = GNUNET_new (struct ProtoQueue);
+
+  if (NULL == sock)
+  {
+    // sock = GNUNET_CONNECTION_create_from_sockaddr (AF_INET, addr, addrlen);
+    sock = GNUNET_NETWORK_socket_create (in->sa_family, SOCK_STREAM, 0);
+    if (NULL == sock)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "socket(%d) failed: %s",
+                  in->sa_family,
+                  strerror (errno));
+      GNUNET_free (in);
+      GNUNET_free (pq);
+      return NULL;
+    }
+    if ((GNUNET_OK != GNUNET_NETWORK_socket_connect (sock, in, addrlen)) &&
+        (errno != EINPROGRESS))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "connect to `%s' failed: %s",
+                  GNUNET_a2s (in, addrlen),
+                  strerror (errno));
+      GNUNET_NETWORK_socket_close (sock);
+      GNUNET_free (in);
+      GNUNET_free (pq);
+      return NULL;
+    }
+  }
+  pq->address_len = addrlen;
+  pq->address = in;
+  pq->timeout = GNUNET_TIME_relative_to_absolute (PROTO_QUEUE_TIMEOUT);
+  pq->sock = sock;
+  pq->read_task = GNUNET_SCHEDULER_add_read_net (PROTO_QUEUE_TIMEOUT,
+                                                 pq->sock,
+                                                 &proto_read_kx,
+                                                 pq);
+  GNUNET_CONTAINER_DLL_insert (proto_head, proto_tail, pq);
+
+  return pq;
+}
+
+
+/**
+ * We have been notified that our listen socket has something to
+ * read. Do the read and reschedule this function to be called again
+ * once more is available.
+ *
+ * @param cls ListenTask with listening socket and task
+ */
+static void
+listen_cb (void *cls)
+{
+  struct sockaddr_storage in;
+  socklen_t addrlen;
+  struct GNUNET_NETWORK_Handle *sock;
+  struct ListenTask *lt;
+  struct sockaddr *in_addr;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "listen_cb\n");
+
+  lt = cls;
+
+  lt->listen_task = NULL;
+  GNUNET_assert (NULL != lt->listen_sock);
+  addrlen = sizeof(in);
+  memset (&in, 0, sizeof(in));
+  sock = GNUNET_NETWORK_socket_accept (lt->listen_sock,
+                                       (struct sockaddr*) &in,
+                                       &addrlen);
+  if ((NULL == sock) && ((EMFILE == errno) || (ENFILE == errno)))
+    return; /* system limit reached, wait until connection goes down */
+  lt->listen_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                                   lt->listen_sock,
+                                                   &listen_cb,
+                                                   lt);
+  if ((NULL == sock) && ((EAGAIN == errno) || (ENOBUFS == errno)))
+    return;
+  if (NULL == sock)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "accept");
+    return;
+  }
+  in_addr = GNUNET_memdup (&in, addrlen);
+  create_proto_queue (sock, in_addr, addrlen);
+}
+
+
+static void
+try_connection_reversal (void *cls,
+                         const struct sockaddr *addr,
+                         socklen_t addrlen)
+{
+  (void) cls;
+  struct TCPNATProbeMessage pm;
+  struct ProtoQueue *pq;
+  struct sockaddr *in_addr;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "addr->sa_family %d\n",
+              addr->sa_family);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Try to connect back\n");
+  in_addr = GNUNET_memdup (addr, addrlen);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "in_addr->sa_family %d\n",
+              in_addr->sa_family);
+  pq = create_proto_queue (NULL, in_addr, addrlen);
+  if (NULL != pq)
+  {
+    pm.header.size = htons (sizeof(struct TCPNATProbeMessage));
+    pm.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_TCP_NAT_PROBE);
+    pm.clientIdentity = my_identity;
+    memcpy (pq->write_buf, &pm, sizeof(struct TCPNATProbeMessage));
+    pq->write_off = sizeof(struct TCPNATProbeMessage);
+    pq->write_task = GNUNET_SCHEDULER_add_write_net (PROTO_QUEUE_TIMEOUT,
+                                                     pq->sock,
+                                                     &proto_queue_write,
+                                                     pq);
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Couldn't create ProtoQueue for sending TCPNATProbeMessage\n");
+  }
+}
+
+
+static void
+pending_reversal_timeout (void *cls)
+{
+  struct sockaddr *in = cls;
+  struct PendingReversal *pending_reversal;
+  struct GNUNET_HashCode key;
+
+  GNUNET_CRYPTO_hash (in,
+                      sizeof(struct sockaddr),
+                      &key);
+  pending_reversal = GNUNET_CONTAINER_multihashmap_get (pending_reversals,
+                                                        &key);
+
+  GNUNET_assert (NULL != pending_reversal);
+
+  if (GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove (pending_reversals,
+                                                         &key,
+                                                         pending_reversal))
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "No pending reversal found for address %s\n",
+                GNUNET_a2s (in, sizeof (struct sockaddr)));
+  GNUNET_free (pending_reversal->in);
+  GNUNET_free (pending_reversal);
+}
+
+
+/**
+ * Function called by the transport service to initialize a
+ * message queue given address information about another peer.
+ * If and when the communication channel is established, the
+ * communicator must call #GNUNET_TRANSPORT_communicator_mq_add()
+ * to notify the service that the channel is now up.  It is
+ * the responsibility of the communicator to manage sane
+ * retries and timeouts for any @a peer/@a address combination
+ * provided by the transport service.  Timeouts and retries
+ * do not need to be signalled to the transport service.
+ *
+ * @param cls closure
+ * @param peer identity of the other peer
+ * @param address where to send the message, human-readable
+ *        communicator-specific format, 0-terminated, UTF-8
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if the provided address is
+ * invalid
+ */
+static int
+mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
+{
+  struct sockaddr *in;
+  socklen_t in_len = 0;
+  const char *path;
+  struct sockaddr_in *v4;
+  struct sockaddr_in6 *v6;
+  unsigned int is_natd = GNUNET_NO;
+  struct GNUNET_HashCode key;
+  struct GNUNET_HashCode queue_map_key;
+  struct GNUNET_HashContext *hsh;
+  struct Queue *queue;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Connecting to %s at %s\n",
+              GNUNET_i2s (peer),
+              address);
+  if (0 != strncmp (address,
+                    COMMUNICATOR_ADDRESS_PREFIX "-",
+                    strlen (COMMUNICATOR_ADDRESS_PREFIX "-")))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  path = &address[strlen (COMMUNICATOR_ADDRESS_PREFIX "-")];
+  in = tcp_address_to_sockaddr (path, &in_len);
+
+  if (NULL == in)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to setup TCP socket address\n");
+    return GNUNET_SYSERR;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "in %s\n",
+              GNUNET_a2s (in, in_len));
+
+  hsh = GNUNET_CRYPTO_hash_context_start ();
+  GNUNET_CRYPTO_hash_context_read (hsh, address, strlen (address));
+  GNUNET_CRYPTO_hash_context_read (hsh, peer, sizeof (*peer));
+  GNUNET_CRYPTO_hash_context_finish (hsh, &queue_map_key);
+  queue = GNUNET_CONTAINER_multihashmap_get (queue_map, &queue_map_key);
+
+  if (NULL != queue)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Queue for %s already exists or is in construction\n", address);
+    GNUNET_free (in);
+    return GNUNET_NO;
+  }
+  switch (in->sa_family)
+  {
+  case AF_INET:
+    v4 = (struct sockaddr_in *) in;
+    if (0 == v4->sin_port)
+    {
+      is_natd = GNUNET_YES;
+      GNUNET_CRYPTO_hash (in,
+                          sizeof(struct sockaddr),
+                          &key);
+      if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (
+            pending_reversals,
+            &key))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    "There is already a request reversal for `%s'at `%s'\n",
+                    GNUNET_i2s (peer),
+                    address);
+        GNUNET_free (in);
+        return GNUNET_SYSERR;
+      }
+    }
+    break;
+
+  case AF_INET6:
+    if (GNUNET_YES == disable_v6)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "IPv6 disabled, skipping %s\n", address);
+      GNUNET_free (in);
+      return GNUNET_SYSERR;
+    }
+    v6 = (struct sockaddr_in6 *) in;
+    if (0 == v6->sin6_port)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Request reversal for `%s' at `%s' not possible for an IPv6 address\n",
+                  GNUNET_i2s (peer),
+                  address);
+      GNUNET_free (in);
+      return GNUNET_SYSERR;
+    }
+    break;
+
+  default:
+    GNUNET_assert (0);
+  }
+
+  if (GNUNET_YES == is_natd)
+  {
+    struct sockaddr_in local_sa;
+    struct PendingReversal *pending_reversal;
+
+    memset (&local_sa, 0, sizeof(local_sa));
+    local_sa.sin_family = AF_INET;
+    local_sa.sin_port = htons (bind_port);
+    /* We leave sin_address at 0, let the kernel figure it out,
+       even if our bind() is more specific.  (May want to reconsider
+       later.) */
+    if (GNUNET_OK != GNUNET_NAT_request_reversal (nat, &local_sa, v4))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "request reversal for `%s' at `%s' failed\n",
+                  GNUNET_i2s (peer),
+                  address);
+      GNUNET_free (in);
+      return GNUNET_SYSERR;
+    }
+    pending_reversal = GNUNET_new (struct PendingReversal);
+    pending_reversal->in = in;
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multihashmap_put (pending_reversals,
+                                                      &key,
+                                                      pending_reversal,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+    pending_reversal->target = *peer;
+    pending_reversal->timeout_task = GNUNET_SCHEDULER_add_delayed (NAT_TIMEOUT,
+                                                                   &
+                                                                   pending_reversal_timeout,
+                                                                   in);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Created NAT WAIT connection to `%s' at `%s'\n",
+                GNUNET_i2s (peer),
+                GNUNET_a2s (in, sizeof (struct sockaddr)));
+  }
+  else
+  {
+    struct GNUNET_NETWORK_Handle *sock;
+
+    sock = GNUNET_NETWORK_socket_create (in->sa_family, SOCK_STREAM,
+                                         IPPROTO_TCP);
+    if (NULL == sock)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "socket(%d) failed: %s",
+                  in->sa_family,
+                  strerror (errno));
+      GNUNET_free (in);
+      return GNUNET_SYSERR;
+    }
+    if ((GNUNET_OK != GNUNET_NETWORK_socket_connect (sock, in, in_len)) &&
+        (errno != EINPROGRESS))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "connect to `%s' failed: %s",
+                  address,
+                  strerror (errno));
+      GNUNET_NETWORK_socket_close (sock);
+      GNUNET_free (in);
+      return GNUNET_SYSERR;
+    }
+
+    queue = GNUNET_new (struct Queue);
+    queue->target = *peer;
+    queue->key = queue_map_key;
+    queue->address = in;
+    queue->address_len = in_len;
+    queue->sock = sock;
+    queue->cs = GNUNET_TRANSPORT_CS_OUTBOUND;
+    boot_queue (queue);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "booted queue with target %s\n",
+                GNUNET_i2s (&queue->target));
+    // queue->mq_awaits_continue = GNUNET_YES;
+    queue->read_task =
+      GNUNET_SCHEDULER_add_read_net (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+                                     queue->sock,
+                                     &queue_read_kx,
+                                     queue);
+
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "start kx mq_init\n");
+
+    start_initial_kx_out (queue);
+    queue->write_task =
+      GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                      queue->sock,
+                                      &queue_write,
+                                      queue);
+  }
+
+  return GNUNET_OK;
+}
+
+
+/**
+ * Iterator over all ListenTasks to clean up.
+ *
+ * @param cls NULL
+ * @param key unused
+ * @param value the ListenTask to cancel.
+ * @return #GNUNET_OK to continue to iterate
+ */
+static int
+get_lt_delete_it (void *cls,
+                  const struct GNUNET_HashCode *key,
+                  void *value)
+{
+  struct ListenTask *lt = value;
+
+  (void) cls;
+  (void) key;
+  if (NULL != lt->listen_task)
+  {
+    GNUNET_SCHEDULER_cancel (lt->listen_task);
+    lt->listen_task = NULL;
+  }
+  if (NULL != lt->listen_sock)
+  {
+    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (lt->listen_sock));
+    lt->listen_sock = NULL;
+  }
+  GNUNET_free (lt);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Iterator over all message queues to clean up.
+ *
+ * @param cls NULL
+ * @param target unused
+ * @param value the queue to destroy
+ * @return #GNUNET_OK to continue to iterate
+ */
+static int
+get_queue_delete_it (void *cls,
+                     const struct GNUNET_HashCode *target,
+                     void *value)
+{
+  struct Queue *queue = value;
+
+  (void) cls;
+  (void) target;
+  queue_destroy (queue);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Shutdown the UNIX communicator.
+ *
+ * @param cls NULL (always)
+ */
+static void
+do_shutdown (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Shutdown %s!\n",
+              shutdown_running ? "running" : "not running");
+
+  if (GNUNET_YES == shutdown_running)
+    return;
+  else
+    shutdown_running = GNUNET_YES;
+
+  while (NULL != proto_head)
+    free_proto_queue (proto_head);
+  if (NULL != nat)
+  {
+    GNUNET_NAT_unregister (nat);
+    nat = NULL;
+  }
+  GNUNET_CONTAINER_multihashmap_iterate (pending_reversals,
+                                         &pending_reversals_delete_it, NULL);
+  GNUNET_CONTAINER_multihashmap_destroy (pending_reversals);
+  GNUNET_CONTAINER_multihashmap_iterate (lt_map, &get_lt_delete_it, NULL);
+  GNUNET_CONTAINER_multihashmap_destroy (lt_map);
+  GNUNET_CONTAINER_multihashmap_iterate (queue_map, &get_queue_delete_it, NULL);
+  GNUNET_CONTAINER_multihashmap_destroy (queue_map);
+  if (NULL != ch)
+  {
+    GNUNET_TRANSPORT_communicator_address_remove_all (ch);
+    GNUNET_TRANSPORT_communicator_disconnect (ch);
+    ch = NULL;
+  }
+  if (NULL != stats)
+  {
+    GNUNET_STATISTICS_destroy (stats, GNUNET_YES);
+    stats = NULL;
+  }
+  if (NULL != my_private_key)
+  {
+    GNUNET_free (my_private_key);
+    my_private_key = NULL;
+  }
+  if (NULL != is)
+  {
+    GNUNET_NT_scanner_done (is);
+    is = NULL;
+  }
+  if (NULL != peerstore)
+  {
+    GNUNET_PEERSTORE_disconnect (peerstore);
+    peerstore = NULL;
+  }
+  if (NULL != resolve_request_handle)
+  {
+    GNUNET_RESOLVER_request_cancel (resolve_request_handle);
+    resolve_request_handle = NULL;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Shutdown done!\n");
+}
+
+
+/**
+ * Function called when the transport service has received an
+ * acknowledgement for this communicator (!) via a different return
+ * path.
+ *
+ * Not applicable for TCP.
+ *
+ * @param cls closure
+ * @param sender which peer sent the notification
+ * @param msg payload
+ */
+static void
+enc_notify_cb (void *cls,
+               const struct GNUNET_PeerIdentity *sender,
+               const struct GNUNET_MessageHeader *msg)
+{
+  (void) cls;
+  (void) sender;
+  (void) msg;
+  GNUNET_break_op (0);
+}
+
+
+/**
+ * Signature of the callback passed to #GNUNET_NAT_register() for
+ * a function to call whenever our set of 'valid' addresses changes.
+ *
+ * @param cls closure
+ * @param[in,out] app_ctx location where the app can store stuff
+ *                  on add and retrieve it on remove
+ * @param add_remove #GNUNET_YES to add a new public IP address,
+ *                   #GNUNET_NO to remove a previous (now invalid) one
+ * @param ac address class the address belongs to
+ * @param addr either the previous or the new public IP address
+ * @param addrlen actual length of the @a addr
+ */
+static void
+nat_address_cb (void *cls,
+                void **app_ctx,
+                int add_remove,
+                enum GNUNET_NAT_AddressClass ac,
+                const struct sockaddr *addr,
+                socklen_t addrlen)
+{
+  char *my_addr;
+  struct GNUNET_TRANSPORT_AddressIdentifier *ai;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "nat address cb %s %s\n",
+              add_remove ? "add" : "remove",
+              GNUNET_a2s (addr, addrlen));
+
+  if (GNUNET_YES == add_remove)
+  {
+    enum GNUNET_NetworkType nt;
+
+    GNUNET_asprintf (&my_addr,
+                     "%s-%s",
+                     COMMUNICATOR_ADDRESS_PREFIX,
+                     GNUNET_a2s (addr, addrlen));
+    nt = GNUNET_NT_scanner_get_type (is, addr, addrlen);
+    ai =
+      GNUNET_TRANSPORT_communicator_address_add (ch,
+                                                 my_addr,
+                                                 nt,
+                                                 GNUNET_TIME_UNIT_FOREVER_REL);
+    GNUNET_free (my_addr);
+    *app_ctx = ai;
+  }
+  else
+  {
+    ai = *app_ctx;
+    GNUNET_TRANSPORT_communicator_address_remove (ai);
+    *app_ctx = NULL;
+  }
+}
+
+
+/**
+ * This method adds addresses to the DLL, that are later register at the NAT service.
+ */
+static void
+add_addr (struct sockaddr *in, socklen_t in_len)
+{
+
+  struct Addresses *saddrs;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "add address %s\n",
+              GNUNET_a2s (in, in_len));
+
+  saddrs = GNUNET_new (struct Addresses);
+  saddrs->addr = in;
+  saddrs->addr_len = in_len;
+  GNUNET_CONTAINER_DLL_insert (addrs_head, addrs_tail, saddrs);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "after add address %s\n",
+              GNUNET_a2s (in, in_len));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "add address %s\n",
+              GNUNET_a2s (saddrs->addr, saddrs->addr_len));
+
+  addrs_lens++;
+}
+
+
+/**
+ * This method launch network interactions for each address we like to bind to.
+ *
+ * @param addr The address we will listen to.
+ * @param in_len The length of the address we will listen to.
+ * @return GNUNET_SYSERR in case of error. GNUNET_OK in case we are successfully listen to the address.
+ */
+static int
+init_socket (struct sockaddr *addr,
+             socklen_t in_len)
+{
+  struct sockaddr_storage in_sto;
+  socklen_t sto_len;
+  struct GNUNET_NETWORK_Handle *listen_sock;
+  struct ListenTask *lt;
+  int sockfd;
+  struct GNUNET_HashCode h_sock;
+
+  if (NULL == addr)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Address is NULL.\n");
+    return GNUNET_SYSERR;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "address %s\n",
+              GNUNET_a2s (addr, in_len));
+
+  listen_sock =
+    GNUNET_NETWORK_socket_create (addr->sa_family, SOCK_STREAM, IPPROTO_TCP);
+  if (NULL == listen_sock)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
+    return GNUNET_SYSERR;
+  }
+
+  if (GNUNET_OK != GNUNET_NETWORK_socket_bind (listen_sock, addr, in_len))
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
+    GNUNET_NETWORK_socket_close (listen_sock);
+    listen_sock = NULL;
+    return GNUNET_SYSERR;
+  }
+
+  if (GNUNET_OK !=
+      GNUNET_NETWORK_socket_listen (listen_sock,
+                                    5))
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
+                         "listen");
+    GNUNET_NETWORK_socket_close (listen_sock);
+    listen_sock = NULL;
+    return GNUNET_SYSERR;
+  }
+
+  /* We might have bound to port 0, allowing the OS to figure it out;
+     thus, get the real IN-address from the socket */
+  sto_len = sizeof(in_sto);
+
+  if (0 != getsockname (GNUNET_NETWORK_get_fd (listen_sock),
+                        (struct sockaddr *) &in_sto,
+                        &sto_len))
+  {
+    memcpy (&in_sto, addr, in_len);
+    sto_len = in_len;
+  }
+
+  // addr = (struct sockaddr *) &in_sto;
+  in_len = sto_len;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Bound to `%s'\n",
+              GNUNET_a2s ((const struct sockaddr *) &in_sto, sto_len));
+  if (NULL == stats)
+    stats = GNUNET_STATISTICS_create ("communicator-tcp", cfg);
+
+  if (NULL == is)
+    is = GNUNET_NT_scanner_init ();
+
+  if (NULL == my_private_key)
+    my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
+  if (NULL == my_private_key)
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_ERROR,
+      _ (
+        "Transport service is lacking key configuration settings. Exiting.\n"));
+    if (NULL != resolve_request_handle)
+      GNUNET_RESOLVER_request_cancel (resolve_request_handle);
+    GNUNET_SCHEDULER_shutdown ();
+    return GNUNET_SYSERR;
+  }
+  GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key);
+  /* start listening */
+
+  lt = GNUNET_new (struct ListenTask);
+  lt->listen_sock = listen_sock;
+
+  lt->listen_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                                   listen_sock,
+                                                   &listen_cb,
+                                                   lt);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "creating hash\n");
+  sockfd = GNUNET_NETWORK_get_fd (lt->listen_sock);
+  GNUNET_CRYPTO_hash (&sockfd,
+                      sizeof(int),
+                      &h_sock);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "creating map\n");
+  if (NULL == lt_map)
+    lt_map = GNUNET_CONTAINER_multihashmap_create (2, GNUNET_NO);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "creating map entry\n");
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multihashmap_put (lt_map,
+                                                    &h_sock,
+                                                    lt,
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "map entry created\n");
+
+  if (NULL == queue_map)
+    queue_map = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);
+
+  if (NULL == ch)
+    ch = GNUNET_TRANSPORT_communicator_connect (cfg,
+                                                COMMUNICATOR_CONFIG_SECTION,
+                                                COMMUNICATOR_ADDRESS_PREFIX,
+                                                GNUNET_TRANSPORT_CC_RELIABLE,
+                                                &mq_init,
+                                                NULL,
+                                                &enc_notify_cb,
+                                                NULL);
+
+  if (NULL == ch)
+  {
+    GNUNET_break (0);
+    if (NULL != resolve_request_handle)
+      GNUNET_RESOLVER_request_cancel (resolve_request_handle);
+    GNUNET_SCHEDULER_shutdown ();
+    return GNUNET_SYSERR;
+  }
+
+  add_addr (addr, in_len);
+  return GNUNET_OK;
+
+}
+
+
+/**
+ * This method reads from the DLL addrs_head to register them at the NAT service.
+ */
+static void
+nat_register ()
+{
+  struct sockaddr **saddrs;
+  socklen_t *saddr_lens;
+  int i;
+  size_t len;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "starting nat register!\n");
+  len = 0;
+  i = 0;
+  saddrs = GNUNET_malloc ((addrs_lens) * sizeof(struct sockaddr *));
+  saddr_lens = GNUNET_malloc ((addrs_lens) * sizeof(socklen_t));
+  for (struct Addresses *pos = addrs_head; NULL != pos; pos = pos->next)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "registering address %s\n",
+                GNUNET_a2s (addrs_head->addr, addrs_head->addr_len));
+
+    saddr_lens[i] = addrs_head->addr_len;
+    len += saddr_lens[i];
+    saddrs[i] = GNUNET_memdup (addrs_head->addr, saddr_lens[i]);
+    i++;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "registering addresses %lu %lu %lu %lu\n",
+              (addrs_lens) * sizeof(struct sockaddr *),
+              (addrs_lens) * sizeof(socklen_t),
+              len,
+              sizeof(COMMUNICATOR_CONFIG_SECTION));
+  nat = GNUNET_NAT_register (cfg,
+                             COMMUNICATOR_CONFIG_SECTION,
+                             IPPROTO_TCP,
+                             addrs_lens,
+                             (const struct sockaddr **) saddrs,
+                             saddr_lens,
+                             &nat_address_cb,
+                             try_connection_reversal,
+                             NULL /* closure */);
+  for (i = addrs_lens - 1; i >= 0; i--)
+    GNUNET_free (saddrs[i]);
+  GNUNET_free (saddrs);
+  GNUNET_free (saddr_lens);
+
+  if (NULL == nat)
+  {
+    GNUNET_break (0);
+    if (NULL != resolve_request_handle)
+      GNUNET_RESOLVER_request_cancel (resolve_request_handle);
+    GNUNET_SCHEDULER_shutdown ();
+  }
+}
+
+
+/**
+ * This method is the callback called by the resolver API, and wraps method init_socket.
+ *
+ * @param cls The port we will bind to.
+ * @param addr The address we will bind to.
+ * @param in_len The length of the address we will bind to.
+ */
+static void
+init_socket_resolv (void *cls,
+                    const struct sockaddr *addr,
+                    socklen_t in_len)
+{
+  struct sockaddr_in *v4;
+  struct sockaddr_in6 *v6;
+  struct sockaddr *in;
+
+  (void) cls;
+  if (NULL != addr)
+  {
+    if (AF_INET == addr->sa_family)
+    {
+      v4 = (struct sockaddr_in *) addr;
+      in = tcp_address_to_sockaddr_numeric_v4 (&in_len, *v4, bind_port);// _global);
+    }
+    else if (AF_INET6 == addr->sa_family)
+    {
+      v6 = (struct sockaddr_in6 *) addr;
+      in = tcp_address_to_sockaddr_numeric_v6 (&in_len, *v6, bind_port);// _global);
+    }
+    else
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Address family %u not suitable (not AF_INET %u nor AF_INET6 %u \n",
+                  addr->sa_family,
+                  AF_INET,
+                  AF_INET6);
+      return;
+    }
+    init_socket (in, in_len);
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Address is NULL. This might be an error or the resolver finished resolving.\n");
+    if (NULL == addrs_head)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Resolver finished resolving, but we do not listen to an address!.\n");
+      return;
+    }
+    nat_register ();
+  }
+}
+
+
+/**
+ * Setup communicator and launch network interactions.
+ *
+ * @param cls NULL (always)
+ * @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)
+{
+  char *bindto;
+  struct sockaddr *in;
+  socklen_t in_len;
+  struct sockaddr_in v4;
+  struct sockaddr_in6 v6;
+  char *start;
+  unsigned int port;
+  char dummy[2];
+  char *rest = NULL;
+  struct PortOnlyIpv4Ipv6 *po;
+  socklen_t addr_len_ipv4;
+  socklen_t addr_len_ipv6;
+
+  (void) cls;
+
+  pending_reversals = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
+  memset (&v4,0,sizeof(struct sockaddr_in));
+  memset (&v6,0,sizeof(struct sockaddr_in6));
+  cfg = c;
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             COMMUNICATOR_CONFIG_SECTION,
+                                             "BINDTO",
+                                             &bindto))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               COMMUNICATOR_CONFIG_SECTION,
+                               "BINDTO");
+    return;
+  }
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_number (cfg,
+                                             COMMUNICATOR_CONFIG_SECTION,
+                                             "MAX_QUEUE_LENGTH",
+                                             &max_queue_length))
+  {
+    max_queue_length = DEFAULT_MAX_QUEUE_LENGTH;
+  }
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_time (cfg,
+                                           COMMUNICATOR_CONFIG_SECTION,
+                                           "REKEY_INTERVAL",
+                                           &rekey_interval))
+  {
+    rekey_interval = DEFAULT_REKEY_INTERVAL;
+  }
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_number (cfg,
+                                             COMMUNICATOR_CONFIG_SECTION,
+                                             "REKEY_MAX_BYTES",
+                                             &rekey_max_bytes))
+  {
+    rekey_max_bytes = REKEY_MAX_BYTES;
+  }
+  disable_v6 = GNUNET_NO;
+  if ((GNUNET_NO == GNUNET_NETWORK_test_pf (PF_INET6)) ||
+      (GNUNET_YES ==
+       GNUNET_CONFIGURATION_get_value_yesno (cfg,
+                                             COMMUNICATOR_CONFIG_SECTION,
+                                             "DISABLE_V6")))
+  {
+    disable_v6 = GNUNET_YES;
+  }
+  peerstore = GNUNET_PEERSTORE_connect (cfg);
+  if (NULL == peerstore)
+  {
+    GNUNET_free (bindto);
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+
+  if (1 == sscanf (bindto, "%u%1s", &bind_port, dummy))
+  {
+    po = tcp_address_to_sockaddr_port_only (bindto, &bind_port);
+    addr_len_ipv4 = po->addr_len_ipv4;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "address po %s\n",
+                GNUNET_a2s (po->addr_ipv4, addr_len_ipv4));
+    if (NULL != po->addr_ipv4)
+    {
+      init_socket (po->addr_ipv4, addr_len_ipv4);
+    }
+    if (NULL != po->addr_ipv6)
+    {
+      addr_len_ipv6 = po->addr_len_ipv6;
+      init_socket (po->addr_ipv6, addr_len_ipv6);
+    }
+    GNUNET_free (po);
+    nat_register ();
+    GNUNET_free (bindto);
+    return;
+  }
+
+  start = extract_address (bindto);
+  // FIXME: check for NULL == start...
+  if (1 == inet_pton (AF_INET, start, &v4.sin_addr))
+  {
+    bind_port = extract_port (bindto);
+
+    in = tcp_address_to_sockaddr_numeric_v4 (&in_len, v4, bind_port);
+    init_socket (in, in_len);
+    nat_register ();
+    GNUNET_free (start);
+    GNUNET_free (bindto);
+    return;
+  }
+
+  if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
+  {
+    bind_port = extract_port (bindto);
+    in = tcp_address_to_sockaddr_numeric_v6 (&in_len, v6, bind_port);
+    init_socket (in, in_len);
+    nat_register ();
+    GNUNET_free (start);
+    GNUNET_free (bindto);
+    return;
+  }
+
+  bind_port = extract_port (bindto);
+  resolve_request_handle = GNUNET_RESOLVER_ip_get (strtok_r (bindto,
+                                                             ":",
+                                                             &rest),
+                                                   AF_UNSPEC,
+                                                   GNUNET_TIME_UNIT_MINUTES,
+                                                   &init_socket_resolv,
+                                                   &port);
+
+  GNUNET_free (bindto);
+  GNUNET_free (start);
+}
+
+
+/**
+ * The main function for the UNIX communicator.
+ *
+ * @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
+  };
+  int ret;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Starting tcp communicator\n");
+  if (GNUNET_OK !=
+      GNUNET_STRINGS_get_utf8_args (argc, argv,
+                                    &argc, &argv))
+    return 2;
+
+  ret = (GNUNET_OK ==
+         GNUNET_PROGRAM_run (argc,
+                             argv,
+                             "gnunet-communicator-tcp",
+                             _ ("GNUnet TCP communicator"),
+                             options,
+                             &run,
+                             NULL))
+        ? 0
+        : 1;
+  GNUNET_free_nz ((void *) argv);
+  return ret;
+}
+
+
+/* end of gnunet-communicator-tcp.c */
diff --git a/src/service/transport/gnunet-communicator-udp.c b/src/service/transport/gnunet-communicator-udp.c
new file mode 100644
index 000000000..fa5294218
--- /dev/null
+++ b/src/service/transport/gnunet-communicator-udp.c
@@ -0,0 +1,3665 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2010-2014, 2018, 2019 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 transport/gnunet-communicator-udp.c
+ * @brief Transport plugin using UDP.
+ * @author Christian Grothoff
+ *
+ * TODO:
+ * - consider imposing transmission limits in the absence
+ *   of ACKs; or: maybe this should be done at TNG service level?
+ *   (at least the receiver might want to enforce limits on
+ *    KX/DH operations per sender in here) (#5552)
+ * - overall, we should look more into flow control support
+ *   (either in backchannel, or general solution in TNG service)
+ * - handle addresses discovered from broadcasts (#5551)
+ *   (think: what was the story again on address validation?
+ *    where is the API for that!?!)
+ * - support DNS names in BINDTO option (#5528)
+ * - support NAT connection reversal method (#5529)
+ * - support other UDP-specific NAT traversal methods (#)
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_signatures.h"
+#include "gnunet_constants.h"
+#include "gnunet_nat_service.h"
+#include "gnunet_statistics_service.h"
+#include "gnunet_transport_application_service.h"
+#include "gnunet_transport_communication_service.h"
+
+/**
+ * How often do we rekey based on time (at least)
+ */
+#define DEFAULT_REKEY_TIME_INTERVAL GNUNET_TIME_UNIT_DAYS
+
+/**
+ * How long do we wait until we must have received the initial KX?
+ */
+#define PROTO_QUEUE_TIMEOUT GNUNET_TIME_UNIT_MINUTES
+
+/**
+ * How often do we broadcast our presence on the LAN?
+ */
+#define BROADCAST_FREQUENCY GNUNET_TIME_UNIT_MINUTES
+
+/**
+ * How often do we scan for changes to our network interfaces?
+ */
+#define INTERFACE_SCAN_FREQUENCY \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
+
+/**
+ * How long do we believe our addresses to remain up (before
+ * the other peer should revalidate).
+ */
+#define ADDRESS_VALIDITY_PERIOD GNUNET_TIME_UNIT_HOURS
+
+#define WORKING_QUEUE_INTERVALL \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS,1)
+
+/**
+ * AES key size.
+ */
+#define AES_KEY_SIZE (256 / 8)
+
+/**
+ * AES (GCM) IV size.
+ */
+#define AES_IV_SIZE (96 / 8)
+
+/**
+ * Size of the GCM tag.
+ */
+#define GCM_TAG_SIZE (128 / 8)
+
+#define GENERATE_AT_ONCE 64
+
+/**
+ * If we fall below this number of available KCNs,
+ * we generate additional ACKs until we reach
+ * #KCN_TARGET.
+ * Should be large enough that we don't generate ACKs all
+ * the time and still have enough time for the ACK to
+ * arrive before the sender runs out. So really this
+ * should ideally be based on the RTT.
+ */
+#define KCN_THRESHOLD 96
+
+/**
+ * How many KCNs do we keep around *after* we hit
+ * the #KCN_THRESHOLD? Should be larger than
+ * #KCN_THRESHOLD so we do not generate just one
+ * ACK at the time.
+ */
+#define KCN_TARGET 128
+
+/**
+ * What is the maximum delta between KCN sequence numbers
+ * that we allow. Used to expire 'ancient' KCNs that likely
+ * were dropped by the network.  Must be larger than
+ * KCN_TARGET (otherwise we generate new KCNs all the time),
+ * but not too large (otherwise packet loss may cause
+ * sender to fall back to KX needlessly when sender runs
+ * out of ACK'ed KCNs due to losses).
+ */
+#define MAX_SQN_DELTA 160
+
+/**
+ * How many shared master secrets do we keep around
+ * at most per sender?  Should be large enough so
+ * that we generally have a chance of sending an ACK
+ * before the sender already rotated out the master
+ * secret.  Generally values around #KCN_TARGET make
+ * sense. Might make sense to adapt to RTT if we had
+ * a good measurement...
+ */
+#define MAX_SECRETS 256
+
+/**
+ * Default value for how often we do rekey based on number of bytes transmitted?
+ * (additionally randomized).
+ */
+#define DEFAULT_REKEY_MAX_BYTES (1024LLU * 1024 * 1024 * 4LLU)
+
+/**
+ * Address prefix used by the communicator.
+ */
+
+#define COMMUNICATOR_ADDRESS_PREFIX "udp"
+
+/**
+ * Configuration section used by the communicator.
+ */
+#define COMMUNICATOR_CONFIG_SECTION "communicator-udp"
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+
+/**
+ * Signature we use to verify that the ephemeral key was really chosen by
+ * the specified sender.  If possible, the receiver should respond with
+ * a `struct UDPAck` (possibly via backchannel).
+ */
+struct UdpHandshakeSignature
+{
+  /**
+   * Purpose must be #GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_HANDSHAKE
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+
+  /**
+   * Identity of the inititor of the UDP connection (UDP client).
+   */
+  struct GNUNET_PeerIdentity sender;
+
+  /**
+   * Presumed identity of the target of the UDP connection (UDP server)
+   */
+  struct GNUNET_PeerIdentity receiver;
+
+  /**
+   * Ephemeral key used by the @e sender.
+   */
+  struct GNUNET_CRYPTO_EcdhePublicKey ephemeral;
+
+  /**
+   * Monotonic time of @e sender, to possibly help detect replay attacks
+   * (if receiver persists times by sender).
+   */
+  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
+};
+
+
+/**
+ * "Plaintext" header at beginning of KX message. Followed
+ * by encrypted `struct UDPConfirmation`.
+ */
+struct InitialKX
+{
+  /**
+   * Representative of ephemeral key for KX.
+   */
+  struct GNUNET_CRYPTO_ElligatorRepresentative representative;
+
+  /**
+   * HMAC for the following encrypted message, using GCM.  HMAC uses
+   * key derived from the handshake with sequence number zero.
+   */
+  uint8_t gcm_tag[GCM_TAG_SIZE];
+
+};
+
+
+/**
+ * Encrypted continuation of UDP initial handshake, followed
+ * by message header with payload.
+ */
+struct UDPConfirmation
+{
+  /**
+   * Sender's identity
+   */
+  struct GNUNET_PeerIdentity sender;
+
+  /**
+   * Sender's signature of type #GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_HANDSHAKE
+   */
+  struct GNUNET_CRYPTO_EddsaSignature sender_sig;
+
+  /**
+   * Monotonic time of @e sender, to possibly help detect replay attacks
+   * (if receiver persists times by sender).
+   */
+  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
+
+  /* followed by messages */
+
+  /* padding may follow actual messages */
+};
+
+
+/**
+ * UDP key acknowledgement.  May be sent via backchannel. Allows the
+ * sender to use `struct UDPBox` with the acknowledge key henceforth.
+ */
+struct UDPAck
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Sequence acknowledgement limit. Specifies current maximum sequence
+   * number supported by receiver.
+   */
+  uint32_t sequence_ack GNUNET_PACKED;
+
+  /**
+   * CMAC of the base key being acknowledged.
+   */
+  struct GNUNET_HashCode cmac;
+};
+
+
+/**
+ * Signature we use to verify that the broadcast was really made by
+ * the peer that claims to have made it.  Basically, affirms that the
+ * peer is really using this IP address (albeit possibly not in _our_
+ * LAN).  Makes it difficult for peers in the LAN to claim to
+ * be just any global peer -- an attacker must have at least
+ * shared a LAN with the peer they're pretending to be here.
+ */
+struct UdpBroadcastSignature
+{
+  /**
+   * Purpose must be #GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+
+  /**
+   * Identity of the inititor of the UDP broadcast.
+   */
+  struct GNUNET_PeerIdentity sender;
+
+  /**
+   * Hash of the sender's UDP address.
+   */
+  struct GNUNET_HashCode h_address;
+};
+
+
+/**
+ * Broadcast by peer in LAN announcing its presence.  Unusual in that
+ * we don't pad these to full MTU, as we cannot prevent being
+ * recognized in LAN as GNUnet peers if this feature is enabled
+ * anyway.  Also, the entire message is in cleartext.
+ */
+struct UDPBroadcast
+{
+  /**
+   * Sender's peer identity.
+   */
+  struct GNUNET_PeerIdentity sender;
+
+  /**
+   * Sender's signature of type
+   * #GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST
+   */
+  struct GNUNET_CRYPTO_EddsaSignature sender_sig;
+};
+
+
+/**
+ * UDP message box.  Always sent encrypted, only allowed after
+ * the receiver sent a `struct UDPAck` for the base key!
+ */
+struct UDPBox
+{
+  /**
+   * Key and IV identification code. KDF applied to an acknowledged
+   * base key and a sequence number.  Sequence numbers must be used
+   * monotonically increasing up to the maximum specified in
+   * `struct UDPAck`. Without further `struct UDPAck`s, the sender
+   * must fall back to sending handshakes!
+   */
+  struct GNUNET_ShortHashCode kid;
+
+  /**
+   * 128-bit authentication tag for the following encrypted message,
+   * from GCM.  MAC starts at the @e body_start that follows and
+   * extends until the end of the UDP payload.  If the @e hmac is
+   * wrong, the receiver should check if the message might be a
+   * `struct UdpHandshakeSignature`.
+   */
+  uint8_t gcm_tag[GCM_TAG_SIZE];
+
+};
+
+/**
+ * Plaintext of a rekey payload in a UDPBox.
+ */
+struct UDPRekey
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_REKEY.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Ephemeral key to rekey with.
+   */
+  struct GNUNET_CRYPTO_EcdhePublicKey ephemeral;
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+/**
+ * Shared secret we generated for a particular sender or receiver.
+ */
+struct SharedSecret;
+
+
+/**
+ * Pre-generated "kid" code (key and IV identification code) to
+ * quickly derive master key for a `struct UDPBox`.
+ */
+struct KeyCacheEntry
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct KeyCacheEntry *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct KeyCacheEntry *prev;
+
+  /**
+   * Key and IV identification code. KDF applied to an acknowledged
+   * base key and a sequence number.  Sequence numbers must be used
+   * monotonically increasing up to the maximum specified in
+   * `struct UDPAck`. Without further `struct UDPAck`s, the sender
+   * must fall back to sending handshakes!
+   */
+  struct GNUNET_ShortHashCode kid;
+
+  /**
+   * Corresponding shared secret.
+   */
+  struct SharedSecret *ss;
+
+  /**
+   * Sequence number used to derive this entry from master key.
+   */
+  uint32_t sequence_number;
+};
+
+
+/**
+ * Information we track per sender address we have recently been
+ * in contact with (decryption from sender).
+ */
+struct SenderAddress;
+
+/**
+ * Information we track per receiving address we have recently been
+ * in contact with (encryption to receiver).
+ */
+struct ReceiverAddress;
+
+/**
+ * Shared secret we generated for a particular sender or receiver.
+ */
+struct SharedSecret
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct SharedSecret *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct SharedSecret *prev;
+
+  /**
+   * Kept in a DLL, sorted by sequence number. Only if we are decrypting.
+   */
+  struct KeyCacheEntry *kce_head;
+
+  /**
+   * Kept in a DLL, sorted by sequence number. Only if we are decrypting.
+   */
+  struct KeyCacheEntry *kce_tail;
+
+  /**
+   * Sender we use this shared secret with, or NULL.
+   */
+  struct SenderAddress *sender;
+
+  /**
+   * Receiver we use this shared secret with, or NULL.
+   */
+  struct ReceiverAddress *receiver;
+
+  /**
+   * Master shared secret.
+   */
+  struct GNUNET_HashCode master;
+
+  /**
+   * CMAC is used to identify @e master in ACKs.
+   */
+  struct GNUNET_HashCode cmac;
+
+  /**
+   * Up to which sequence number did we use this @e master already?
+   * (for encrypting only)
+   */
+  uint32_t sequence_used;
+
+  /**
+   * Up to which sequence number did the other peer allow us to use
+   * this key, or up to which number did we allow the other peer to
+   * use this key?
+   */
+  uint32_t sequence_allowed;
+
+  /**
+   * Number of active KCN entries.
+   */
+  unsigned int active_kce_count;
+
+  /**
+   * Bytes sent with this shared secret
+   */
+  size_t bytes_sent;
+
+  /**
+   * rekey initiated for this secret?
+   */
+  int rekey_initiated;
+
+  /**
+   * Also precompute keys despite sufficient acks (for rekey)
+   */
+  int override_available_acks;
+};
+
+
+/**
+ * Information we track per sender address we have recently been
+ * in contact with (we decrypt messages from the sender).
+ */
+struct SenderAddress
+{
+  /**
+   * To whom are we talking to.
+   */
+  struct GNUNET_PeerIdentity target;
+
+  /**
+   * Entry in sender expiration heap.
+   */
+  struct GNUNET_CONTAINER_HeapNode *hn;
+
+  /**
+   * Shared secrets we used with @e target, first used is head.
+   */
+  struct SharedSecret *ss_head;
+
+  /**
+   * Shared secrets we used with @e target, last used is tail.
+   */
+  struct SharedSecret *ss_tail;
+
+  /**
+   * Address of the other peer.
+   */
+  struct sockaddr *address;
+
+  /**
+   * Length of the address.
+   */
+  socklen_t address_len;
+
+  /**
+   * The address key for this entry.
+   */
+  struct GNUNET_HashCode key;
+
+  /**
+   * Timeout for this sender.
+   */
+  struct GNUNET_TIME_Absolute timeout;
+
+  /**
+   * Length of the DLL at @a ss_head.
+   */
+  unsigned int num_secrets;
+
+  /**
+   * Number of BOX keys from ACKs we have currently
+   * available for this sender.
+   */
+  unsigned int acks_available;
+
+  /**
+   * Which network type does this queue use?
+   */
+  enum GNUNET_NetworkType nt;
+
+  /**
+   * sender_destroy already called on sender.
+   */
+  int sender_destroy_called;
+
+  /**
+   * ID of kce working queue task
+   */
+  struct GNUNET_SCHEDULER_Task *kce_task;
+
+  /**
+   * Is the kce_task finished?
+   */
+  int kce_task_finished;
+
+  /**
+   * When KCE finishes, send ACK if GNUNET_YES
+   */
+  int kce_send_ack_on_finish;
+};
+
+
+/**
+ * Information we track per receiving address we have recently been
+ * in contact with (encryption to receiver).
+ */
+struct ReceiverAddress
+{
+  /**
+  * Timeout for this receiver address.
+  */
+  struct GNUNET_TIME_Absolute rekey_timeout;
+
+  /**
+   * To whom are we talking to.
+   */
+  struct GNUNET_PeerIdentity target;
+
+  /**
+   * The address key for this entry.
+   */
+  struct GNUNET_HashCode key;
+
+  /**
+   * Shared secrets we received from @e target, first used is head.
+   */
+  struct SharedSecret *ss_head;
+
+  /**
+   * Shared secrets we received with @e target, last used is tail.
+   */
+  struct SharedSecret *ss_tail;
+
+  /**
+   * Address of the receiver in the human-readable format
+   * with the #COMMUNICATOR_ADDRESS_PREFIX.
+   */
+  char *foreign_addr;
+
+  /**
+   * Address of the other peer.
+   */
+  struct sockaddr *address;
+
+  /**
+   * Length of the address.
+   */
+  socklen_t address_len;
+
+  /**
+   * Entry in sender expiration heap.
+   */
+  struct GNUNET_CONTAINER_HeapNode *hn;
+
+  /**
+   * KX message queue we are providing for the #ch.
+   */
+  struct GNUNET_MQ_Handle *kx_mq;
+
+  /**
+   * Default message queue we are providing for the #ch.
+   */
+  struct GNUNET_MQ_Handle *d_mq;
+
+  /**
+   * handle for KX queue with the #ch.
+   */
+  struct GNUNET_TRANSPORT_QueueHandle *kx_qh;
+
+  /**
+   * handle for default queue with the #ch.
+   */
+  struct GNUNET_TRANSPORT_QueueHandle *d_qh;
+
+  /**
+   * Timeout for this receiver address.
+   */
+  struct GNUNET_TIME_Absolute timeout;
+
+  /**
+   * MTU we allowed transport for this receiver's KX queue.
+   */
+  size_t kx_mtu;
+
+  /**
+   * MTU we allowed transport for this receiver's default queue.
+   */
+  size_t d_mtu;
+
+  /**
+   * Length of the DLL at @a ss_head.
+   */
+  unsigned int num_secrets;
+
+  /**
+   * Number of BOX keys from ACKs we have currently
+   * available for this receiver.
+   */
+  unsigned int acks_available;
+
+  /**
+   * Which network type does this queue use?
+   */
+  enum GNUNET_NetworkType nt;
+
+  /**
+   * receiver_destroy already called on receiver.
+   */
+  int receiver_destroy_called;
+};
+
+/**
+ * Interface we broadcast our presence on.
+ */
+struct BroadcastInterface
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct BroadcastInterface *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct BroadcastInterface *prev;
+
+  /**
+   * Task for this broadcast interface.
+   */
+  struct GNUNET_SCHEDULER_Task *broadcast_task;
+
+  /**
+   * Sender's address of the interface.
+   */
+  struct sockaddr *sa;
+
+  /**
+   * Broadcast address to use on the interface.
+   */
+  struct sockaddr *ba;
+
+  /**
+   * Message we broadcast on this interface.
+   */
+  struct UDPBroadcast bcm;
+
+  /**
+   * If this is an IPv6 interface, this is the request
+   * we use to join/leave the group.
+   */
+  struct ipv6_mreq mcreq;
+
+  /**
+   * Number of bytes in @e sa.
+   */
+  socklen_t salen;
+
+  /**
+   * Was this interface found in the last #iface_proc() scan?
+   */
+  int found;
+};
+
+/**
+ * The rekey interval
+ */
+static struct GNUNET_TIME_Relative rekey_interval;
+
+/**
+ * How often we do rekey based on number of bytes transmitted
+ */
+static unsigned long long rekey_max_bytes;
+
+/**
+ * Cache of pre-generated key IDs.
+ */
+static struct GNUNET_CONTAINER_MultiShortmap *key_cache;
+
+/**
+ * ID of read task
+ */
+static struct GNUNET_SCHEDULER_Task *read_task;
+
+/**
+ * ID of timeout task
+ */
+static struct GNUNET_SCHEDULER_Task *timeout_task;
+
+/**
+ * ID of master broadcast task
+ */
+static struct GNUNET_SCHEDULER_Task *broadcast_task;
+
+/**
+ * For logging statistics.
+ */
+static struct GNUNET_STATISTICS_Handle *stats;
+
+/**
+ * Our environment.
+ */
+static struct GNUNET_TRANSPORT_CommunicatorHandle *ch;
+
+/**
+ * Receivers (map from peer identity to `struct ReceiverAddress`)
+ */
+static struct GNUNET_CONTAINER_MultiHashMap *receivers;
+
+/**
+ * Senders (map from peer identity to `struct SenderAddress`)
+ */
+static struct GNUNET_CONTAINER_MultiHashMap *senders;
+
+/**
+ * Expiration heap for senders (contains `struct SenderAddress`)
+ */
+static struct GNUNET_CONTAINER_Heap *senders_heap;
+
+/**
+ * Expiration heap for receivers (contains `struct ReceiverAddress`)
+ */
+static struct GNUNET_CONTAINER_Heap *receivers_heap;
+
+/**
+ * Broadcast interface tasks. Kept in a DLL.
+ */
+static struct BroadcastInterface *bi_head;
+
+/**
+ * Broadcast interface tasks. Kept in a DLL.
+ */
+static struct BroadcastInterface *bi_tail;
+
+/**
+ * Our socket.
+ */
+static struct GNUNET_NETWORK_Handle *udp_sock;
+
+/**
+ * #GNUNET_YES if #udp_sock supports IPv6.
+ */
+static int have_v6_socket;
+
+/**
+ * Our public key.
+ */
+static struct GNUNET_PeerIdentity my_identity;
+
+/**
+ * Our private key.
+ */
+static struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
+
+/**
+ * Our configuration.
+ */
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Our handle to report addresses for validation to TRANSPORT.
+ */
+static struct GNUNET_TRANSPORT_ApplicationHandle *ah;
+
+/**
+ * Network scanner to determine network types.
+ */
+static struct GNUNET_NT_InterfaceScanner *is;
+
+/**
+ * Connection to NAT service.
+ */
+static struct GNUNET_NAT_Handle *nat;
+
+/**
+ * Port number to which we are actually bound.
+ */
+static uint16_t my_port;
+
+/**
+ * IPv6 disabled or not.
+ */
+static int disable_v6;
+
+
+/**
+ * An interface went away, stop broadcasting on it.
+ *
+ * @param bi entity to close down
+ */
+static void
+bi_destroy (struct BroadcastInterface *bi)
+{
+  if (AF_INET6 == bi->sa->sa_family)
+  {
+    /* Leave the multicast group */
+    if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock,
+                                                       IPPROTO_IPV6,
+                                                       IPV6_LEAVE_GROUP,
+                                                       &bi->mcreq,
+                                                       sizeof(bi->mcreq)))
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
+    }
+  }
+  GNUNET_CONTAINER_DLL_remove (bi_head, bi_tail, bi);
+  GNUNET_SCHEDULER_cancel (bi->broadcast_task);
+  GNUNET_free (bi->sa);
+  GNUNET_free (bi->ba);
+  GNUNET_free (bi);
+}
+
+static int
+secret_destroy (struct SharedSecret *ss);
+
+/**
+ * Destroys a receiving state due to timeout or shutdown.
+ *
+ * @param receiver entity to close down
+ */
+static void
+receiver_destroy (struct ReceiverAddress *receiver)
+{
+  struct SharedSecret *ss;
+  receiver->receiver_destroy_called = GNUNET_YES;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Disconnecting receiver for peer `%s'\n",
+              GNUNET_i2s (&receiver->target));
+  if (NULL != receiver->kx_qh)
+  {
+    GNUNET_TRANSPORT_communicator_mq_del (receiver->kx_qh);
+    receiver->kx_qh = NULL;
+    receiver->kx_mq = NULL;
+  }
+  if (NULL != receiver->d_qh)
+  {
+    GNUNET_TRANSPORT_communicator_mq_del (receiver->d_qh);
+    receiver->d_qh = NULL;
+  }
+  else if (NULL != receiver->d_mq)
+  {
+    GNUNET_MQ_destroy (receiver->d_mq);
+    receiver->d_mq = NULL;
+  }
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_remove (receivers,
+                                                       &receiver->key,
+                                                       receiver));
+  GNUNET_assert (receiver == GNUNET_CONTAINER_heap_remove_node (receiver->hn));
+  GNUNET_STATISTICS_set (stats,
+                         "# receivers active",
+                         GNUNET_CONTAINER_multihashmap_size (receivers),
+                         GNUNET_NO);
+  while (NULL != (ss = receiver->ss_head))
+  {
+    secret_destroy (ss);
+  }
+  GNUNET_free (receiver->address);
+  GNUNET_free (receiver->foreign_addr);
+  GNUNET_free (receiver);
+}
+
+
+/**
+ * Free memory used by key cache entry.
+ *
+ * @param kce the key cache entry
+ */
+static void
+kce_destroy (struct KeyCacheEntry *kce)
+{
+  struct SharedSecret *ss = kce->ss;
+
+  ss->active_kce_count--;
+  GNUNET_CONTAINER_DLL_remove (ss->kce_head, ss->kce_tail, kce);
+  GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multishortmap_remove (key_cache,
+                                                                      &kce->kid,
+                                                                      kce));
+  GNUNET_free (kce);
+}
+
+
+/**
+ * Compute @a kid.
+ *
+ * @param msec master secret for HMAC calculation
+ * @param serial number for the @a smac calculation
+ * @param[out] kid where to write the key ID
+ */
+static void
+get_kid (const struct GNUNET_HashCode *msec,
+         uint32_t serial,
+         struct GNUNET_ShortHashCode *kid)
+{
+  uint32_t sid = htonl (serial);
+
+  GNUNET_CRYPTO_hkdf (kid,
+                      sizeof(*kid),
+                      GCRY_MD_SHA512,
+                      GCRY_MD_SHA256,
+                      &sid,
+                      sizeof(sid),
+                      msec,
+                      sizeof(*msec),
+                      "UDP-KID",
+                      strlen ("UDP-KID"),
+                      NULL,
+                      0);
+}
+
+
+/**
+ * Setup key cache entry for sequence number @a seq and shared secret @a ss.
+ *
+ * @param ss shared secret
+ * @param seq sequence number for the key cache entry
+ */
+static void
+kce_generate (struct SharedSecret *ss, uint32_t seq)
+{
+  struct KeyCacheEntry *kce;
+
+  GNUNET_assert (0 < seq);
+  kce = GNUNET_new (struct KeyCacheEntry);
+  kce->ss = ss;
+  kce->sequence_number = seq;
+  get_kid (&ss->master, seq, &kce->kid);
+  GNUNET_CONTAINER_DLL_insert (ss->kce_head, ss->kce_tail, kce);
+  ss->active_kce_count++;
+  ss->sender->acks_available++;
+  (void) GNUNET_CONTAINER_multishortmap_put (
+    key_cache,
+    &kce->kid,
+    kce,
+    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  GNUNET_STATISTICS_set (stats,
+                         "# KIDs active",
+                         GNUNET_CONTAINER_multishortmap_size (key_cache),
+                         GNUNET_NO);
+}
+
+
+/**
+ * Destroy @a ss and associated key cache entries.
+ *
+ * @param ss shared secret to destroy
+ * @param withoutKce If GNUNET_YES shared secrets with kce will not be destroyed.
+ */
+static int
+secret_destroy (struct SharedSecret *ss)
+{
+  struct SenderAddress *sender;
+  struct ReceiverAddress *receiver;
+  struct KeyCacheEntry *kce;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "secret %s destroy %u\n",
+              GNUNET_h2s (&ss->master),
+              ss->sequence_allowed);
+  if (NULL != (sender = ss->sender))
+  {
+    GNUNET_CONTAINER_DLL_remove (sender->ss_head, sender->ss_tail, ss);
+    sender->num_secrets--;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%u sender->num_secrets %u allowed %u used, %u available\n",
+                sender->num_secrets, ss->sequence_allowed, ss->sequence_used,
+                sender->acks_available);
+    sender->acks_available -= (ss->sequence_allowed - ss->sequence_used);
+    if (NULL != ss->sender->kce_task)
+    {
+      GNUNET_SCHEDULER_cancel (ss->sender->kce_task);
+      ss->sender->kce_task = NULL;
+    }
+  }
+  if (NULL != (receiver = ss->receiver))
+  {
+    GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss);
+    receiver->num_secrets--;
+    receiver->acks_available -= (ss->sequence_allowed - ss->sequence_used);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%u receiver->num_secrets\n",
+                receiver->num_secrets);
+  }
+  while (NULL != (kce = ss->kce_head))
+    kce_destroy (kce);
+  GNUNET_STATISTICS_update (stats, "# Secrets active", -1, GNUNET_NO);
+  GNUNET_STATISTICS_set (stats,
+                         "# KIDs active",
+                         GNUNET_CONTAINER_multishortmap_size (key_cache),
+                         GNUNET_NO);
+  GNUNET_free (ss);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Functions with this signature are called whenever we need
+ * to close a sender's state due to timeout.
+ *
+ * @param sender entity to close down
+ */
+static void
+sender_destroy (struct SenderAddress *sender)
+{
+  struct SharedSecret *ss;
+  sender->sender_destroy_called = GNUNET_YES;
+  GNUNET_assert (
+    GNUNET_YES ==
+    GNUNET_CONTAINER_multihashmap_remove (senders, &sender->key, sender));
+  GNUNET_assert (sender == GNUNET_CONTAINER_heap_remove_node (sender->hn));
+  GNUNET_STATISTICS_set (stats,
+                         "# senders active",
+                         GNUNET_CONTAINER_multihashmap_size (senders),
+                         GNUNET_NO);
+  while (NULL != (ss = sender->ss_head))
+  {
+    secret_destroy (ss);
+  }
+  GNUNET_free (sender->address);
+  GNUNET_free (sender);
+}
+
+
+/**
+ * Compute @a key and @a iv.
+ *
+ * @param msec master secret for calculation
+ * @param serial number for the @a smac calculation
+ * @param[out] key where to write the decryption key
+ * @param[out] iv where to write the IV
+ */
+static void
+get_iv_key (const struct GNUNET_HashCode *msec,
+            uint32_t serial,
+            char key[AES_KEY_SIZE],
+            char iv[AES_IV_SIZE])
+{
+  uint32_t sid = htonl (serial);
+  char res[AES_KEY_SIZE + AES_IV_SIZE];
+
+  GNUNET_CRYPTO_hkdf (res,
+                      sizeof(res),
+                      GCRY_MD_SHA512,
+                      GCRY_MD_SHA256,
+                      &sid,
+                      sizeof(sid),
+                      msec,
+                      sizeof(*msec),
+                      "UDP-IV-KEY",
+                      strlen ("UDP-IV-KEY"),
+                      NULL,
+                      0);
+  memcpy (key, res, AES_KEY_SIZE);
+  memcpy (iv, &res[AES_KEY_SIZE], AES_IV_SIZE);
+}
+
+
+/**
+ * Increment sender timeout due to activity.
+ *
+ * @param sender address for which the timeout should be rescheduled
+ */
+static void
+reschedule_sender_timeout (struct SenderAddress *sender)
+{
+  sender->timeout =
+    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+  GNUNET_CONTAINER_heap_update_cost (sender->hn, sender->timeout.abs_value_us);
+}
+
+
+/**
+ * Increment receiver timeout due to activity.
+ *
+ * @param receiver address for which the timeout should be rescheduled
+ */
+static void
+reschedule_receiver_timeout (struct ReceiverAddress *receiver)
+{
+  receiver->timeout =
+    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+  GNUNET_CONTAINER_heap_update_cost (receiver->hn,
+                                     receiver->timeout.abs_value_us);
+}
+
+
+/**
+ * Task run to check #receiver_heap and #sender_heap for timeouts.
+ *
+ * @param cls unused, NULL
+ */
+static void
+check_timeouts (void *cls)
+{
+  struct GNUNET_TIME_Relative st;
+  struct GNUNET_TIME_Relative rt;
+  struct GNUNET_TIME_Relative delay;
+  struct ReceiverAddress *receiver;
+  struct SenderAddress *sender;
+
+  (void) cls;
+  timeout_task = NULL;
+  rt = GNUNET_TIME_UNIT_FOREVER_REL;
+  while (NULL != (receiver = GNUNET_CONTAINER_heap_peek (receivers_heap)))
+  {
+    rt = GNUNET_TIME_absolute_get_remaining (receiver->timeout);
+    if (0 != rt.rel_value_us)
+      break;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Receiver timed out\n");
+    receiver_destroy (receiver);
+  }
+  st = GNUNET_TIME_UNIT_FOREVER_REL;
+  while (NULL != (sender = GNUNET_CONTAINER_heap_peek (senders_heap)))
+  {
+    if (GNUNET_YES != sender->sender_destroy_called)
+    {
+      st = GNUNET_TIME_absolute_get_remaining (sender->timeout);
+      if (0 != st.rel_value_us)
+        break;
+      sender_destroy (sender);
+    }
+  }
+  delay = GNUNET_TIME_relative_min (rt, st);
+  if (delay.rel_value_us < GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
+    timeout_task = GNUNET_SCHEDULER_add_delayed (delay, &check_timeouts, NULL);
+}
+
+
+/**
+ * Calculate cmac from master in @a ss.
+ *
+ * @param[in,out] ss data structure to complete
+ */
+static void
+calculate_cmac (struct SharedSecret *ss)
+{
+  GNUNET_CRYPTO_hkdf (&ss->cmac,
+                      sizeof(ss->cmac),
+                      GCRY_MD_SHA512,
+                      GCRY_MD_SHA256,
+                      "CMAC",
+                      strlen ("CMAC"),
+                      &ss->master,
+                      sizeof(ss->master),
+                      "UDP-CMAC",
+                      strlen ("UDP-CMAC"),
+                      NULL,
+                      0);
+}
+
+
+/**
+ * We received @a plaintext_len bytes of @a plaintext from a @a sender.
+ * Pass it on to CORE.
+ *
+ * @param queue the queue that received the plaintext
+ * @param plaintext the plaintext that was received
+ * @param plaintext_len number of bytes of plaintext received
+ */
+static void
+pass_plaintext_to_core (struct SenderAddress *sender,
+                        const void *plaintext,
+                        size_t plaintext_len)
+{
+  const struct GNUNET_MessageHeader *hdr = plaintext;
+  const char *pos = plaintext;
+
+  while (ntohs (hdr->size) <= plaintext_len)
+  {
+    GNUNET_STATISTICS_update (stats,
+                              "# bytes given to core",
+                              ntohs (hdr->size),
+                              GNUNET_NO);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Giving %u bytes to TNG\n", ntohs (hdr->size));
+    GNUNET_assert (GNUNET_SYSERR !=
+                   GNUNET_TRANSPORT_communicator_receive (ch,
+                                                          &sender->target,
+                                                          hdr,
+                                                          ADDRESS_VALIDITY_PERIOD,
+                                                          NULL /* no flow control possible */
+                                                          ,
+                                                          NULL));
+    /* move on to next message, if any */
+    plaintext_len -= ntohs (hdr->size);
+    if (plaintext_len < sizeof(*hdr))
+      break;
+    pos += ntohs (hdr->size);
+    hdr = (const struct GNUNET_MessageHeader *) pos;
+    // TODO for now..., we do not actually sen >1msg or have a way of telling
+    // if we are done
+    break;
+  }
+  GNUNET_STATISTICS_update (stats,
+                            "# bytes padding discarded",
+                            plaintext_len,
+                            GNUNET_NO);
+}
+
+
+/**
+ * Setup @a cipher based on shared secret @a msec and
+ * serial number @a serial.
+ *
+ * @param msec master shared secret
+ * @param serial serial number of cipher to set up
+ * @param cipher[out] cipher to initialize
+ */
+static void
+setup_cipher (const struct GNUNET_HashCode *msec,
+              uint32_t serial,
+              gcry_cipher_hd_t *cipher)
+{
+  char key[AES_KEY_SIZE];
+  char iv[AES_IV_SIZE];
+  int rc;
+
+  GNUNET_assert (0 ==
+                 gcry_cipher_open (cipher,
+                                   GCRY_CIPHER_AES256 /* low level: go for speed */
+                                   ,
+                                   GCRY_CIPHER_MODE_GCM,
+                                   0 /* flags */));
+  get_iv_key (msec, serial, key, iv);
+  rc = gcry_cipher_setkey (*cipher, key, sizeof(key));
+  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
+  rc = gcry_cipher_setiv (*cipher, iv, sizeof(iv));
+  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
+}
+
+
+/**
+ * Try to decrypt @a buf using shared secret @a ss and key/iv
+ * derived using @a serial.
+ *
+ * @param ss shared secret
+ * @param tag GCM authentication tag
+ * @param serial serial number to use
+ * @param in_buf input buffer to decrypt
+ * @param in_buf_size number of bytes in @a in_buf and available in @a out_buf
+ * @param out_buf where to write the result
+ * @return #GNUNET_OK on success
+ */
+static int
+try_decrypt (const struct SharedSecret *ss,
+             const uint8_t *tag,
+             uint32_t serial,
+             const char *in_buf,
+             size_t in_buf_size,
+             char *out_buf)
+{
+  gcry_cipher_hd_t cipher;
+
+  setup_cipher (&ss->master, serial, &cipher);
+  GNUNET_assert (
+    0 ==
+    gcry_cipher_decrypt (cipher, out_buf, in_buf_size, in_buf, in_buf_size));
+  if (0 != gcry_cipher_checktag (cipher, tag, GCM_TAG_SIZE))
+  {
+    gcry_cipher_close (cipher);
+    GNUNET_STATISTICS_update (stats,
+                              "# AEAD authentication failures",
+                              1,
+                              GNUNET_NO);
+    return GNUNET_SYSERR;
+  }
+  gcry_cipher_close (cipher);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Setup shared secret for decryption.
+ *
+ * @param ephemeral ephemeral key we received from the other peer
+ * @return new shared secret
+ */
+static struct SharedSecret *
+setup_shared_secret_dec (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral)
+{
+  struct SharedSecret *ss;
+
+  ss = GNUNET_new (struct SharedSecret);
+  GNUNET_CRYPTO_eddsa_kem_decaps (my_private_key, ephemeral, &ss->master);
+  calculate_cmac (ss);
+  return ss;
+}
+
+
+/**
+ * Setup shared secret for decryption for initial handshake.
+ *
+ * @param representative of ephemeral key we received from the other peer
+ * @return new shared secret
+ */
+static struct SharedSecret *
+setup_initial_shared_secret_dec (const struct
+                                 GNUNET_CRYPTO_ElligatorRepresentative *
+                                 representative)
+{
+  struct SharedSecret *ss;
+
+  ss = GNUNET_new (struct SharedSecret);
+  GNUNET_CRYPTO_eddsa_elligator_kem_decaps (my_private_key, representative,
+                                            &ss->master);
+  calculate_cmac (ss);
+  return ss;
+}
+
+
+/**
+ * Setup new shared secret for encryption using KEM.
+ *
+ * @param[out] ephemeral ephemeral key to be sent to other peer (encapsulated key from KEM)
+ * @param[in,out] receiver queue to initialize encryption key for
+ * @return new shared secret
+ */
+static struct SharedSecret *
+setup_shared_secret_ephemeral (struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral,
+                               struct ReceiverAddress *receiver)
+{
+  struct SharedSecret *ss;
+  struct GNUNET_HashCode k;
+
+  GNUNET_CRYPTO_eddsa_kem_encaps (&receiver->target.public_key, ephemeral, &k);
+  ss = GNUNET_new (struct SharedSecret);
+  memcpy (&ss->master, &k, sizeof (k));
+  calculate_cmac (ss);
+  ss->receiver = receiver;
+  GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss);
+  receiver->num_secrets++;
+  GNUNET_STATISTICS_update (stats, "# Secrets active", 1, GNUNET_NO);
+  return ss;
+}
+
+
+/**
+ * Setup new shared secret for encryption using KEM for initial handshake.
+ *
+ * @param[out] representative of ephemeral key to be sent to other peer (encapsulated key from KEM)
+ * @param[in,out] receiver queue to initialize encryption key for
+ * @return new shared secret
+ */
+static struct SharedSecret *
+setup_initial_shared_secret_ephemeral (struct
+                                       GNUNET_CRYPTO_ElligatorRepresentative *
+                                       representative,
+                                       struct ReceiverAddress *receiver)
+{
+  struct SharedSecret *ss;
+  struct GNUNET_HashCode k;
+
+  GNUNET_CRYPTO_eddsa_elligator_kem_encaps (&receiver->target.public_key,
+                                            representative, &k);
+  ss = GNUNET_new (struct SharedSecret);
+  memcpy (&ss->master, &k, sizeof (k));
+  calculate_cmac (ss);
+  ss->receiver = receiver;
+  GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss);
+  receiver->num_secrets++;
+  GNUNET_STATISTICS_update (stats, "# Secrets active", 1, GNUNET_NO);
+  return ss;
+}
+
+
+/**
+ * Setup the MQ for the @a receiver.  If a queue exists,
+ * the existing one is destroyed.  Then the MTU is
+ * recalculated and a fresh queue is initialized.
+ *
+ * @param receiver receiver to setup MQ for
+ */
+static void
+setup_receiver_mq (struct ReceiverAddress *receiver);
+
+
+/**
+ * Best effort try to purge some secrets.
+ * Ideally those, not ACKed.
+ *
+ * @param ss_list_tail the oldest secret in the list of interest.
+ * @return number of deleted secrets.
+ */
+unsigned int
+purge_secrets (struct SharedSecret *ss_list_tail)
+{
+  struct SharedSecret *pos;
+  struct SharedSecret *ss_to_purge;
+  unsigned int deleted = 0;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Purging secrets.\n");
+  pos = ss_list_tail;
+  while (NULL != pos)
+  {
+    ss_to_purge = pos;
+    pos = pos->prev;
+
+    // FIXME we may also want to purge old unacked.
+    if (rekey_max_bytes <= ss_to_purge->bytes_sent)
+    {
+      secret_destroy (ss_to_purge);
+      deleted++;
+    }
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Finished purging all, deleted %u.\n", deleted);
+  return deleted;
+}
+
+
+static void
+add_acks (struct SharedSecret *ss, int acks_to_add)
+{
+
+  struct ReceiverAddress *receiver = ss->receiver;
+
+  GNUNET_assert (NULL != ss);
+  GNUNET_assert (NULL != receiver);
+
+  if (NULL == receiver->d_qh)
+  {
+    receiver->d_qh =
+      GNUNET_TRANSPORT_communicator_mq_add (ch,
+                                            &receiver->target,
+                                            receiver->foreign_addr,
+                                            receiver->d_mtu,
+                                            acks_to_add,
+                                            1, /* Priority */
+                                            receiver->nt,
+                                            GNUNET_TRANSPORT_CS_OUTBOUND,
+                                            receiver->d_mq);
+  }
+  else
+  {
+    GNUNET_TRANSPORT_communicator_mq_update (ch,
+                                             receiver->d_qh,
+                                             acks_to_add,
+                                             1);
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Tell transport we have %u more acks!\n",
+              acks_to_add);
+
+  // Until here for alternativ 1
+
+  /* move ss to head to avoid discarding it anytime soon! */
+
+  // GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss);
+  // GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss);
+}
+
+
+/**
+ * We received an ACK for @a pid. Check if it is for
+ * the receiver in @a value and if so, handle it and
+ * return #GNUNET_NO. Otherwise, return #GNUNET_YES.
+ *
+ * @param cls a `const struct UDPAck`
+ * @param pid peer the ACK is from
+ * @param value a `struct ReceiverAddress`
+ * @return #GNUNET_YES to continue to iterate
+ */
+static int
+handle_ack (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  const struct UDPAck *ack = cls;
+  struct ReceiverAddress *receiver = value;
+  uint32_t acks_to_add;
+  uint32_t allowed;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "in handle ack with cmac %s\n",
+              GNUNET_h2s (&ack->cmac));
+
+  (void) key;
+  for (struct SharedSecret *ss = receiver->ss_head; NULL != ss; ss = ss->next)
+  {
+    if (0 == memcmp (&ack->cmac, &ss->cmac, sizeof(struct GNUNET_HashCode)))
+    {
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Found matching cmac\n");
+
+      allowed = ntohl (ack->sequence_ack);
+
+      if (allowed <= ss->sequence_allowed)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Ignoring ack, not giving us increased window\n.");
+        return GNUNET_NO;
+      }
+      acks_to_add = (allowed - ss->sequence_allowed);
+      GNUNET_assert (0 != acks_to_add);
+      receiver->acks_available += (allowed - ss->sequence_allowed);
+      ss->sequence_allowed = allowed;
+      add_acks (ss, acks_to_add);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "New sequence allows until %u (+%u). Acks available to us: %u. For secret %s\n",
+                  allowed,
+                  acks_to_add,
+                  receiver->acks_available,
+                  GNUNET_h2s (&ss->master));
+      return GNUNET_NO;
+    }
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Matching cmac not found for ack!\n");
+  return GNUNET_YES;
+}
+
+
+/**
+ * We established a shared secret with a sender. We should try to send
+ * the sender an `struct UDPAck` at the next opportunity to allow the
+ * sender to use @a ss longer (assuming we did not yet already
+ * recently).
+ *
+ * @param ss shared secret to generate ACKs for
+ */
+static void
+consider_ss_ack (struct SharedSecret *ss)
+{
+  struct UDPAck ack;
+  GNUNET_assert (NULL != ss->sender);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Considering SS UDPAck %s\n",
+              GNUNET_i2s_full (&ss->sender->target));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sender has %u acks available.\n",
+              ss->sender->acks_available);
+  /* drop ancient KeyCacheEntries */
+  while ((NULL != ss->kce_head) &&
+         (MAX_SQN_DELTA <
+          ss->kce_head->sequence_number - ss->kce_tail->sequence_number))
+    kce_destroy (ss->kce_tail);
+
+
+  ack.header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK);
+  ack.header.size = htons (sizeof(ack));
+  ack.sequence_ack = htonl (ss->sequence_allowed);
+  ack.cmac = ss->cmac;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Notifying transport with UDPAck %s, sequence %u and master %s\n",
+              GNUNET_i2s_full (&ss->sender->target),
+              ss->sequence_allowed,
+              GNUNET_h2s (&(ss->master)));
+  GNUNET_TRANSPORT_communicator_notify (ch,
+                                        &ss->sender->target,
+                                        COMMUNICATOR_ADDRESS_PREFIX,
+                                        &ack.header);
+}
+
+
+static void
+kce_generate_cb (void *cls)
+{
+  struct SharedSecret *ss = cls;
+  ss->sender->kce_task = NULL;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Precomputing %u keys for master %s\n",
+              GENERATE_AT_ONCE,
+              GNUNET_h2s (&(ss->master)));
+  if ((ss->override_available_acks != GNUNET_YES) &&
+      (KCN_TARGET < ss->sender->acks_available))
+    return;
+  for (int i = 0; i < GENERATE_AT_ONCE; i++)
+    kce_generate (ss, ++ss->sequence_allowed);
+
+  /**
+   * As long as we loose over 30% of max acks in reschedule,
+   * We keep generating acks for this ss.
+   */
+  if (KCN_TARGET > ss->sender->acks_available)
+  {
+    ss->sender->kce_task = GNUNET_SCHEDULER_add_delayed (
+      WORKING_QUEUE_INTERVALL,
+      kce_generate_cb,
+      ss);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "We have enough keys (ACKs: %u).\n", ss->sender->acks_available);
+  ss->sender->kce_task_finished = GNUNET_YES;
+  ss->override_available_acks = GNUNET_NO;
+  if (ss->sender->kce_send_ack_on_finish == GNUNET_YES)
+    consider_ss_ack (ss);
+}
+
+
+/**
+ * Test if we have received a valid message in plaintext.
+ * If so, handle it.
+ *
+ * @param sender peer to process inbound plaintext for
+ * @param buf buffer we received
+ * @param buf_size number of bytes in @a buf
+ */
+static void
+try_handle_plaintext (struct SenderAddress *sender,
+                      const void *buf,
+                      size_t buf_size)
+{
+  const struct GNUNET_MessageHeader *hdr;
+  const struct UDPAck *ack;
+  const struct UDPRekey *rekey;
+  struct SharedSecret *ss_rekey;
+  const char *buf_pos = buf;
+  size_t bytes_remaining = buf_size;
+  uint16_t type;
+
+  hdr = (struct GNUNET_MessageHeader*) buf_pos;
+  if (sizeof(*hdr) > bytes_remaining)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Plaintext too short, dropping...\n");
+    return; /* no data left */
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "try_handle_plaintext of size %llu (%u %lu) and type %u\n",
+              (unsigned long long) bytes_remaining,
+              ntohs (hdr->size),
+              sizeof(*hdr),
+              ntohs (hdr->type));
+  if (ntohs (hdr->size) > bytes_remaining)
+    return; /* buffer too short for indicated message length */
+  type = ntohs (hdr->type);
+  switch (type)
+  {
+  case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_REKEY:
+    rekey = (struct UDPRekey*) buf_pos;
+    ss_rekey = setup_shared_secret_dec (&rekey->ephemeral);
+    ss_rekey->sender = sender;
+    GNUNET_CONTAINER_DLL_insert (sender->ss_head, sender->ss_tail, ss_rekey);
+    sender->num_secrets++;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received rekey secret with cmac %s\n",
+                GNUNET_h2s (&(ss_rekey->cmac)));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received secret with master %s.\n",
+                GNUNET_h2s (&(ss_rekey->master)));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "We have %u sequence_allowed.\n",
+                ss_rekey->sequence_allowed);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "We have a sender %p\n",
+                ss_rekey->sender);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "We have %u acks available.\n",
+                ss_rekey->sender->acks_available);
+    GNUNET_STATISTICS_update (stats,
+                              "# rekeying successful",
+                              1,
+                              GNUNET_NO);
+    ss_rekey->sender->kce_send_ack_on_finish = GNUNET_YES;
+    ss_rekey->override_available_acks = GNUNET_YES;
+    // FIXME
+    kce_generate_cb (ss_rekey);
+    /* ss_rekey->sender->kce_task = GNUNET_SCHEDULER_add_delayed (
+      WORKING_QUEUE_INTERVALL,
+      kce_generate_cb,
+      ss_rekey);*/
+    // FIXME: Theoretically, this could be an Ack
+    buf_pos += ntohs (hdr->size);
+    bytes_remaining -= ntohs (hdr->size);
+    pass_plaintext_to_core (sender, buf_pos, bytes_remaining);
+    if (0 == purge_secrets (sender->ss_tail))
+    {
+      // No secret purged. Delete oldest.
+      if (sender->num_secrets > MAX_SECRETS)
+      {
+        secret_destroy (sender->ss_tail);
+      }
+    }
+    break;
+  case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK:
+    /* lookup master secret by 'cmac', then update sequence_max */
+    ack = (struct UDPAck*) buf_pos;
+    GNUNET_CONTAINER_multihashmap_get_multiple (receivers,
+                                                &sender->key,
+                                                &handle_ack,
+                                                (void *) ack);
+    /* There could be more messages after the ACK, handle those as well */
+    buf_pos += ntohs (hdr->size);
+    bytes_remaining -= ntohs (hdr->size);
+    pass_plaintext_to_core (sender, buf_pos, bytes_remaining);
+    break;
+
+  case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD:
+    /* skip padding */
+    break;
+
+  default:
+    pass_plaintext_to_core (sender, buf_pos, bytes_remaining);
+  }
+  return;
+}
+
+
+/**
+ * We received a @a box with matching @a kce.  Decrypt and process it.
+ *
+ * @param box the data we received
+ * @param box_len number of bytes in @a box
+ * @param kce key index to decrypt @a box
+ */
+static void
+decrypt_box (const struct UDPBox *box,
+             size_t box_len,
+             struct KeyCacheEntry *kce)
+{
+  struct SharedSecret *ss = kce->ss;
+  struct SharedSecret *ss_c = ss->sender->ss_tail;
+  struct SharedSecret *ss_tmp;
+  int ss_destroyed = 0;
+  char out_buf[box_len - sizeof(*box)];
+
+  GNUNET_assert (NULL != ss->sender);
+  if (GNUNET_OK != try_decrypt (ss,
+                                box->gcm_tag,
+                                kce->sequence_number,
+                                (const char *) &box[1],
+                                sizeof(out_buf),
+                                out_buf))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed decryption.\n");
+    GNUNET_STATISTICS_update (stats,
+                              "# Decryption failures with valid KCE",
+                              1,
+                              GNUNET_NO);
+    kce_destroy (kce);
+    ss->sender->acks_available--;
+    return;
+  }
+  kce_destroy (kce);
+  kce = NULL;
+  ss->bytes_sent += box_len;
+  ss->sender->acks_available--;
+  ss->sequence_used++;
+  GNUNET_STATISTICS_update (stats,
+                            "# bytes decrypted with BOX",
+                            sizeof(out_buf),
+                            GNUNET_NO);
+  GNUNET_STATISTICS_update (stats,
+                            "# messages decrypted with BOX",
+                            1,
+                            GNUNET_NO);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "decrypted UDPBox with kid %s\n",
+              GNUNET_sh2s (&box->kid));
+  try_handle_plaintext (ss->sender, out_buf, sizeof(out_buf));
+
+  while (NULL != ss_c)
+  {
+    if (ss_c->bytes_sent >= rekey_max_bytes)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Removing SS because rekey bytes reached.\n");
+      ss_tmp = ss_c->prev;
+      if (ss == ss_c)
+        ss_destroyed = 1;
+      secret_destroy (ss_c);
+      ss_c = ss_tmp;
+      continue;
+    }
+    ss_c = ss_c->prev;
+  }
+  if (1 == ss_destroyed)
+    return;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sender has %u ack left.\n",
+              ss->sender->acks_available);
+  if ((KCN_THRESHOLD > ss->sender->acks_available) &&
+      (NULL == ss->sender->kce_task) &&
+      (GNUNET_YES == ss->sender->kce_task_finished))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sender has %u ack left which is under threshold.\n",
+                ss->sender->acks_available);
+    ss->sender->kce_send_ack_on_finish = GNUNET_YES;
+    ss->sender->kce_task = GNUNET_SCHEDULER_add_now (
+      kce_generate_cb,
+      ss);
+  }
+}
+
+
+/**
+ * Closure for #find_sender_by_address()
+ */
+struct SearchContext
+{
+  /**
+   * Address we are looking for.
+   */
+  const struct sockaddr *address;
+
+  /**
+   * Number of bytes in @e address.
+   */
+  socklen_t address_len;
+
+  /**
+   * Return value to set if we found a match.
+   */
+  struct SenderAddress *sender;
+};
+
+
+/**
+ * Create sender address for @a target.  Note that we
+ * might already have one, so a fresh one is only allocated
+ * if one does not yet exist for @a address.
+ *
+ * @param target peer to generate address for
+ * @param address target address
+ * @param address_len number of bytes in @a address
+ * @return data structure to keep track of key material for
+ *         decrypting data from @a target
+ */
+static struct SenderAddress *
+setup_sender (const struct GNUNET_PeerIdentity *target,
+              const struct sockaddr *address,
+              socklen_t address_len)
+{
+  struct SenderAddress *sender;
+  struct GNUNET_HashContext *hsh;
+  struct GNUNET_HashCode sender_key;
+
+  hsh = GNUNET_CRYPTO_hash_context_start ();
+  GNUNET_CRYPTO_hash_context_read (hsh, address, address_len);
+  GNUNET_CRYPTO_hash_context_read (hsh, target, sizeof(*target));
+  GNUNET_CRYPTO_hash_context_finish (hsh, &sender_key);
+
+  sender = GNUNET_CONTAINER_multihashmap_get (senders, &sender_key);
+  if (NULL != sender)
+  {
+    reschedule_sender_timeout (sender);
+    return sender;
+  }
+  sender = GNUNET_new (struct SenderAddress);
+  sender->key = sender_key;
+  sender->target = *target;
+  sender->address = GNUNET_memdup (address, address_len);
+  sender->address_len = address_len;
+  (void) GNUNET_CONTAINER_multihashmap_put (
+    senders,
+    &sender->key,
+    sender,
+    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  GNUNET_STATISTICS_set (stats,
+                         "# senders active",
+                         GNUNET_CONTAINER_multihashmap_size (receivers),
+                         GNUNET_NO);
+  sender->timeout =
+    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+  sender->hn = GNUNET_CONTAINER_heap_insert (senders_heap,
+                                             sender,
+                                             sender->timeout.abs_value_us);
+  sender->nt = GNUNET_NT_scanner_get_type (is, address, address_len);
+  if (NULL == timeout_task)
+    timeout_task = GNUNET_SCHEDULER_add_now (&check_timeouts, NULL);
+  return sender;
+}
+
+
+/**
+ * Check signature from @a uc against @a ephemeral.
+ *
+ * @param ephemeral key that is signed
+ * @param uc signature of claimant
+ * @return #GNUNET_OK if signature is valid
+ */
+static int
+verify_confirmation (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral,
+                     const struct UDPConfirmation *uc)
+{
+  struct UdpHandshakeSignature uhs;
+
+  uhs.purpose.purpose = htonl (
+    GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_HANDSHAKE);
+  uhs.purpose.size = htonl (sizeof(uhs));
+  uhs.sender = uc->sender;
+  uhs.receiver = my_identity;
+  uhs.ephemeral = *ephemeral;
+  uhs.monotonic_time = uc->monotonic_time;
+  return GNUNET_CRYPTO_eddsa_verify (
+    GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_HANDSHAKE,
+    &uhs,
+    &uc->sender_sig,
+    &uc->sender.public_key);
+}
+
+
+/**
+ * Converts @a address to the address string format used by this
+ * communicator in HELLOs.
+ *
+ * @param address the address to convert, must be AF_INET or AF_INET6.
+ * @param address_len number of bytes in @a address
+ * @return string representation of @a address
+ */
+static char *
+sockaddr_to_udpaddr_string (const struct sockaddr *address,
+                            socklen_t address_len)
+{
+  char *ret;
+
+  switch (address->sa_family)
+  {
+  case AF_INET:
+    GNUNET_asprintf (&ret,
+                     "%s-%s",
+                     COMMUNICATOR_ADDRESS_PREFIX,
+                     GNUNET_a2s (address, address_len));
+    break;
+
+  case AF_INET6:
+    GNUNET_asprintf (&ret,
+                     "%s-%s",
+                     COMMUNICATOR_ADDRESS_PREFIX,
+                     GNUNET_a2s (address, address_len));
+    break;
+
+  default:
+    GNUNET_assert (0);
+  }
+  return ret;
+}
+
+
+/**
+ * Socket read task.
+ *
+ * @param cls NULL
+ */
+static void
+sock_read (void *cls)
+{
+  struct sockaddr_storage sa;
+  struct sockaddr_in *addr_verify;
+  socklen_t salen = sizeof(sa);
+  char buf[UINT16_MAX];
+  ssize_t rcvd;
+
+  (void) cls;
+  read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                             udp_sock,
+                                             &sock_read,
+                                             NULL);
+  while (1)
+  {
+    rcvd = GNUNET_NETWORK_socket_recvfrom (udp_sock,
+                                           buf,
+                                           sizeof(buf),
+                                           (struct sockaddr *) &sa,
+                                           &salen);
+    if (-1 == rcvd)
+    {
+      struct sockaddr *addr = (struct sockaddr*) &sa;
+
+      if (EAGAIN == errno)
+        break; // We are done reading data
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Failed to recv from %s family %d failed sock %p\n",
+                  GNUNET_a2s ((struct sockaddr*) &sa,
+                              sizeof (*addr)),
+                  addr->sa_family,
+                  udp_sock);
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "recv");
+      return;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Read %llu bytes\n",
+                (unsigned long long) rcvd);
+    if (0 == rcvd)
+    {
+      GNUNET_break_op (0);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Read 0 bytes from UDP socket\n");
+      return;
+    }
+
+    /* first, see if it is a UDPBox */
+    if (rcvd > sizeof(struct UDPBox))
+    {
+      const struct UDPBox *box;
+      struct KeyCacheEntry *kce;
+
+      box = (const struct UDPBox *) buf;
+      kce = GNUNET_CONTAINER_multishortmap_get (key_cache, &box->kid);
+      if (NULL != kce)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Found KCE with kid %s\n",
+                    GNUNET_sh2s (&box->kid));
+        decrypt_box (box, (size_t) rcvd, kce);
+        continue;
+      }
+    }
+
+    /* next, check if it is a broadcast */
+    if (sizeof(struct UDPBroadcast) == rcvd)
+    {
+      const struct UDPBroadcast *ub;
+      struct UdpBroadcastSignature uhs;
+      struct GNUNET_PeerIdentity sender;
+
+      addr_verify = GNUNET_memdup (&sa, salen);
+      addr_verify->sin_port = 0;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "received UDPBroadcast from %s\n",
+                  GNUNET_a2s ((const struct sockaddr *) addr_verify, salen));
+      ub = (const struct UDPBroadcast *) buf;
+      uhs.purpose.purpose = htonl (
+        GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST);
+      uhs.purpose.size = htonl (sizeof(uhs));
+      uhs.sender = ub->sender;
+      sender = ub->sender;
+      if (0 == memcmp (&sender, &my_identity, sizeof (struct
+                                                      GNUNET_PeerIdentity)))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Received our own broadcast\n");
+        GNUNET_free (addr_verify);
+        continue;
+      }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "checking UDPBroadcastSignature for %s\n",
+                  GNUNET_i2s (&sender));
+      GNUNET_CRYPTO_hash ((struct sockaddr *) addr_verify, salen,
+                          &uhs.h_address);
+      if (GNUNET_OK ==
+          GNUNET_CRYPTO_eddsa_verify (
+            GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST,
+            &uhs,
+            &ub->sender_sig,
+            &ub->sender.public_key))
+      {
+        char *addr_s;
+        enum GNUNET_NetworkType nt;
+
+        addr_s =
+          sockaddr_to_udpaddr_string ((const struct sockaddr *) &sa, salen);
+        GNUNET_STATISTICS_update (stats, "# broadcasts received", 1, GNUNET_NO);
+        /* use our own mechanism to determine network type */
+        nt =
+          GNUNET_NT_scanner_get_type (is, (const struct sockaddr *) &sa, salen);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "validating address %s received from UDPBroadcast\n",
+                    GNUNET_i2s (&sender));
+        GNUNET_TRANSPORT_application_validate (ah, &sender, nt, addr_s);
+        GNUNET_free (addr_s);
+        GNUNET_free (addr_verify);
+        continue;
+      }
+      else
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    "VerifyingPeer %s is verifying UDPBroadcast\n",
+                    GNUNET_i2s (&my_identity));
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    "Verifying UDPBroadcast from %s failed\n",
+                    GNUNET_i2s (&ub->sender));
+      }
+      GNUNET_free (addr_verify);
+      /* continue with KX, mostly for statistics... */
+    }
+
+
+    /* finally, test if it is a KX */
+    if (rcvd < sizeof(struct UDPConfirmation) + sizeof(struct InitialKX))
+    {
+      GNUNET_STATISTICS_update (stats,
+                                "# messages dropped (no kid, too small for KX)",
+                                1,
+                                GNUNET_NO);
+      continue;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Got KX\n");
+    {
+      const struct InitialKX *kx;
+      struct SharedSecret *ss;
+      char pbuf[rcvd - sizeof(struct InitialKX)];
+      const struct UDPConfirmation *uc;
+      struct SenderAddress *sender;
+
+      kx = (const struct InitialKX *) buf;
+      ss = setup_initial_shared_secret_dec (&kx->representative);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Before DEC\n");
+
+      if (GNUNET_OK != try_decrypt (ss,
+                                    kx->gcm_tag,
+                                    0,
+                                    &buf[sizeof(*kx)],
+                                    sizeof(pbuf),
+                                    pbuf))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Unable to decrypt tag, dropping...\n");
+        GNUNET_free (ss);
+        GNUNET_STATISTICS_update (
+          stats,
+          "# messages dropped (no kid, AEAD decryption failed)",
+          1,
+          GNUNET_NO);
+        continue;
+      }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Before VERIFY\n");
+
+      uc = (const struct UDPConfirmation *) pbuf;
+
+      struct GNUNET_CRYPTO_EcdhePublicKey pub_ephemeral;
+      GNUNET_CRYPTO_ecdhe_elligator_decoding (&pub_ephemeral, NULL,
+                                              &kx->representative);
+      if (GNUNET_OK != verify_confirmation (&pub_ephemeral, uc)) // TODO: need ephemeral instead of representative
+      {
+        GNUNET_break_op (0);
+        GNUNET_free (ss);
+        GNUNET_STATISTICS_update (stats,
+                                  "# messages dropped (sender signature invalid)",
+                                  1,
+                                  GNUNET_NO);
+        continue;
+      }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Before SETUP_SENDER\n");
+
+      calculate_cmac (ss);
+      sender = setup_sender (&uc->sender, (const struct sockaddr *) &sa, salen);
+      ss->sender = sender;
+      GNUNET_CONTAINER_DLL_insert (sender->ss_head, sender->ss_tail, ss);
+      if ((KCN_THRESHOLD > ss->sender->acks_available) &&
+          (NULL == ss->sender->kce_task) &&
+          (GNUNET_NO == ss->sender->kce_task_finished))
+      {
+        // TODO This task must be per sender! FIXME: This is a nice todo, but I do not know what must be done here to fix.
+        ss->sender->kce_send_ack_on_finish = GNUNET_YES;
+        ss->sender->kce_task = GNUNET_SCHEDULER_add_now (
+          kce_generate_cb,
+          ss);
+      }
+      sender->num_secrets++;
+      GNUNET_STATISTICS_update (stats, "# Secrets active", 1, GNUNET_NO);
+      GNUNET_STATISTICS_update (stats,
+                                "# messages decrypted without BOX",
+                                1,
+                                GNUNET_NO);
+      try_handle_plaintext (sender, &uc[1], sizeof(pbuf) - sizeof(*uc));
+      if (0 == purge_secrets (sender->ss_tail))
+      {
+        // No secret purged. Delete oldest.
+        if (sender->num_secrets > MAX_SECRETS)
+        {
+          secret_destroy (sender->ss_tail);
+        }
+      }
+    }
+  }
+}
+
+
+/**
+ * Convert UDP bind specification to a `struct sockaddr *`
+ *
+ * @param bindto bind specification to convert
+ * @param[out] sock_len set to the length of the address
+ * @return converted bindto specification
+ */
+static struct sockaddr *
+udp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
+{
+  struct sockaddr *in;
+  unsigned int port;
+  char dummy[2];
+  char *colon;
+  char *cp;
+
+  if (1 == sscanf (bindto, "%u%1s", &port, dummy))
+  {
+    /* interpreting value as just a PORT number */
+    if (port > UINT16_MAX)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "BINDTO specification `%s' invalid: value too large for port\n",
+                  bindto);
+      return NULL;
+    }
+    if (GNUNET_YES == disable_v6)
+    {
+      struct sockaddr_in *i4;
+
+      i4 = GNUNET_malloc (sizeof(struct sockaddr_in));
+      i4->sin_family = AF_INET;
+      i4->sin_port = htons ((uint16_t) port);
+      *sock_len = sizeof(struct sockaddr_in);
+      in = (struct sockaddr *) i4;
+    }
+    else
+    {
+      struct sockaddr_in6 *i6;
+
+      i6 = GNUNET_malloc (sizeof(struct sockaddr_in6));
+      i6->sin6_family = AF_INET6;
+      i6->sin6_port = htons ((uint16_t) port);
+      *sock_len = sizeof(struct sockaddr_in6);
+      in = (struct sockaddr *) i6;
+    }
+    return in;
+  }
+  cp = GNUNET_strdup (bindto);
+  colon = strrchr (cp, ':');
+  if (NULL != colon)
+  {
+    /* interpret value after colon as port */
+    *colon = '\0';
+    colon++;
+    if (1 == sscanf (colon, "%u%1s", &port, dummy))
+    {
+      /* interpreting value as just a PORT number */
+      if (port > UINT16_MAX)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "BINDTO specification `%s' invalid: value too large for port\n",
+                    bindto);
+        GNUNET_free (cp);
+        return NULL;
+      }
+    }
+    else
+    {
+      GNUNET_log (
+        GNUNET_ERROR_TYPE_ERROR,
+        "BINDTO specification `%s' invalid: last ':' not followed by number\n",
+        bindto);
+      GNUNET_free (cp);
+      return NULL;
+    }
+  }
+  else
+  {
+    /* interpret missing port as 0, aka pick any free one */
+    port = 0;
+  }
+  {
+    /* try IPv4 */
+    struct sockaddr_in v4;
+
+    memset (&v4, 0, sizeof(v4));
+    if (1 == inet_pton (AF_INET, cp, &v4.sin_addr))
+    {
+      v4.sin_family = AF_INET;
+      v4.sin_port = htons ((uint16_t) port);
+#if HAVE_SOCKADDR_IN_SIN_LEN
+      v4.sin_len = sizeof(struct sockaddr_in);
+#endif
+      in = GNUNET_memdup (&v4, sizeof(struct sockaddr_in));
+      *sock_len = sizeof(struct sockaddr_in);
+      GNUNET_free (cp);
+      return in;
+    }
+  }
+  {
+    /* try IPv6 */
+    struct sockaddr_in6 v6;
+    const char *start;
+
+    memset (&v6, 0, sizeof(v6));
+    start = cp;
+    if (('[' == *cp) && (']' == cp[strlen (cp) - 1]))
+    {
+      start++;   /* skip over '[' */
+      cp[strlen (cp) - 1] = '\0';  /* eat ']' */
+    }
+    if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
+    {
+      v6.sin6_family = AF_INET6;
+      v6.sin6_port = htons ((uint16_t) port);
+#if HAVE_SOCKADDR_IN_SIN_LEN
+      v6.sin6_len = sizeof(struct sockaddr_in6);
+#endif
+      in = GNUNET_memdup (&v6, sizeof(v6));
+      *sock_len = sizeof(v6);
+      GNUNET_free (cp);
+      return in;
+    }
+  }
+  /* #5528 FIXME (feature!): maybe also try getnameinfo()? */
+  GNUNET_free (cp);
+  return NULL;
+}
+
+
+/**
+ * Pad @a dgram by @a pad_size using @a out_cipher.
+ *
+ * @param out_cipher cipher to use
+ * @param dgram datagram to pad
+ * @param pad_size number of bytes of padding to append
+ */
+static void
+do_pad (gcry_cipher_hd_t out_cipher, char *dgram, size_t pad_size)
+{
+  char pad[pad_size];
+
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, pad, sizeof(pad));
+  if (sizeof(pad) > sizeof(struct GNUNET_MessageHeader))
+  {
+    struct GNUNET_MessageHeader hdr =
+    { .size = htons (sizeof(pad)),
+      .type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD) };
+
+    memcpy (pad, &hdr, sizeof(hdr));
+  }
+  GNUNET_assert (
+    0 ==
+    gcry_cipher_encrypt (out_cipher, dgram, sizeof(pad), pad, sizeof(pad)));
+}
+
+
+static void
+send_msg_with_kx (const struct GNUNET_MessageHeader *msg, struct
+                  ReceiverAddress *receiver,
+                  struct GNUNET_MQ_Handle *mq)
+{
+  uint16_t msize = ntohs (msg->size);
+  struct UdpHandshakeSignature uhs;
+  struct UDPConfirmation uc;
+  struct InitialKX kx;
+  char dgram[receiver->kx_mtu + sizeof(uc) + sizeof(kx)];
+  size_t dpos;
+  gcry_cipher_hd_t out_cipher;
+  struct SharedSecret *ss;
+
+  if (msize > receiver->kx_mtu)
+  {
+    GNUNET_break (0);
+    if (GNUNET_YES != receiver->receiver_destroy_called)
+      receiver_destroy (receiver);
+    return;
+  }
+  reschedule_receiver_timeout (receiver);
+
+  /* setup key material */
+  struct GNUNET_CRYPTO_ElligatorRepresentative repr;
+  ss = setup_initial_shared_secret_ephemeral (&repr, receiver);
+  GNUNET_CRYPTO_ecdhe_elligator_decoding (&uhs.ephemeral, NULL,
+                                          &repr);
+
+  if (0 == purge_secrets (receiver->ss_tail))
+  {
+    // No secret purged. Delete oldest.
+    if (receiver->num_secrets > MAX_SECRETS)
+    {
+      secret_destroy (receiver->ss_tail);
+    }
+  }
+
+  setup_cipher (&ss->master, 0, &out_cipher);
+  /* compute 'uc' */
+  uc.sender = my_identity;
+  uc.monotonic_time =
+    GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg));
+  uhs.purpose.purpose = htonl (
+    GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_HANDSHAKE);
+  uhs.purpose.size = htonl (sizeof(uhs));
+  uhs.sender = my_identity;
+  uhs.receiver = receiver->target;
+  uhs.monotonic_time = uc.monotonic_time;
+  GNUNET_CRYPTO_eddsa_sign (my_private_key,
+                            &uhs,
+                            &uc.sender_sig);
+  /* Leave space for kx */
+  dpos = sizeof(kx);
+  /* Append encrypted uc to dgram */
+  GNUNET_assert (0 == gcry_cipher_encrypt (out_cipher,
+                                           &dgram[dpos],
+                                           sizeof(uc),
+                                           &uc,
+                                           sizeof(uc)));
+  dpos += sizeof(uc);
+  /* Append encrypted payload to dgram */
+  GNUNET_assert (
+    0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize));
+  dpos += msize;
+  do_pad (out_cipher, &dgram[dpos], sizeof(dgram) - dpos);
+  /* Datagram starts with kx */
+  kx.representative = repr;
+  GNUNET_assert (
+    0 == gcry_cipher_gettag (out_cipher, kx.gcm_tag, sizeof(kx.gcm_tag)));
+  gcry_cipher_close (out_cipher);
+  memcpy (dgram, &kx, sizeof(kx));
+  if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock,
+                                          dgram,
+                                          sizeof(dgram),
+                                          receiver->address,
+                                          receiver->address_len))
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send");
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Sending KX with payload size %u to %s family %d failed sock %p\n",
+                msize,
+                GNUNET_a2s (receiver->address,
+                            receiver->address_len),
+                receiver->address->sa_family,
+                udp_sock);
+    GNUNET_MQ_impl_send_continue (mq);
+    receiver_destroy (receiver);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending KX with payload size %u to %s\n",
+              msize,
+              GNUNET_a2s (receiver->address,
+                          receiver->address_len));
+  GNUNET_MQ_impl_send_continue (mq);
+}
+
+
+/**
+ * Signature of functions implementing the sending functionality of a
+ * message queue.
+ *
+ * @param mq the message queue
+ * @param msg the message to send
+ * @param impl_state our `struct ReceiverAddress`
+ */
+static void
+mq_send_kx (struct GNUNET_MQ_Handle *mq,
+            const struct GNUNET_MessageHeader *msg,
+            void *impl_state)
+{
+  struct ReceiverAddress *receiver = impl_state;
+
+  GNUNET_assert (mq == receiver->kx_mq);
+  send_msg_with_kx (msg, receiver, mq);
+}
+
+
+static void
+create_rekey (struct ReceiverAddress *receiver, struct SharedSecret *ss, struct
+              UDPRekey *rekey)
+{
+  struct SharedSecret *ss_rekey;
+
+  ss->rekey_initiated = GNUNET_YES;
+  /* setup key material */
+  ss_rekey = setup_shared_secret_ephemeral (&rekey->ephemeral,
+                                            receiver);
+  ss_rekey->sequence_allowed = 0;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Setup secret with k = %s\n",
+              GNUNET_h2s (&(ss_rekey->master)));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Setup secret with H(k) = %s\n",
+              GNUNET_h2s (&(ss_rekey->cmac)));
+
+  /* Append encrypted payload to dgram */
+  rekey->header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_REKEY);
+  rekey->header.size = htons (sizeof (struct UDPRekey));
+}
+
+
+/**
+ * Signature of functions implementing the sending functionality of a
+ * message queue.
+ *
+ * @param mq the message queue
+ * @param msg the message to send
+ * @param impl_state our `struct ReceiverAddress`
+ */
+static void
+mq_send_d (struct GNUNET_MQ_Handle *mq,
+           const struct GNUNET_MessageHeader *msg,
+           void *impl_state)
+{
+  struct ReceiverAddress *receiver = impl_state;
+  struct UDPRekey rekey;
+  struct SharedSecret *ss;
+  int inject_rekey = GNUNET_NO;
+  uint16_t msize = ntohs (msg->size);
+
+  GNUNET_assert (mq == receiver->d_mq);
+  if ((msize > receiver->d_mtu) ||
+      (0 == receiver->acks_available))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "msize: %u, mtu: %llu, acks: %u\n",
+                (unsigned int) msize,
+                (unsigned long long) receiver->d_mtu,
+                receiver->acks_available);
+
+    GNUNET_break (0);
+    if (GNUNET_YES != receiver->receiver_destroy_called)
+      receiver_destroy (receiver);
+    return;
+  }
+  reschedule_receiver_timeout (receiver);
+
+  if (receiver->num_secrets > MAX_SECRETS)
+  {
+    if ((0 == purge_secrets (receiver->ss_tail)) &&
+        (NULL != receiver->ss_tail))
+    {
+      // No secret purged. Delete oldest.
+      secret_destroy (receiver->ss_tail);
+    }
+  }
+  /* begin "BOX" encryption method, scan for ACKs from tail! */
+  ss = receiver->ss_tail;
+  struct SharedSecret *ss_tmp;
+  while (NULL != ss)
+  {
+    size_t payload_len = sizeof(struct UDPBox) + receiver->d_mtu;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Considering SS %s sequence used: %u sequence allowed: %u bytes sent: %lu.\n",
+                GNUNET_h2s (&ss->master), ss->sequence_used,
+                ss->sequence_allowed, ss->bytes_sent);
+    if (ss->sequence_used >= ss->sequence_allowed)
+    {
+      //  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+      //              "Skipping ss because no acks to use.\n");
+      ss = ss->prev;
+      continue;
+    }
+    if (ss->bytes_sent >= rekey_max_bytes)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Skipping ss because rekey bytes reached.\n");
+      // FIXME cleanup ss with too many bytes sent!
+      ss_tmp = ss->prev;
+      secret_destroy (ss);
+      ss = ss_tmp;
+      continue;
+    }
+    if (ss->bytes_sent > rekey_max_bytes * 0.7)
+    {
+      if (ss->rekey_initiated == GNUNET_NO)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Injecting rekey for ss with byte sent %lu\n",
+                    (unsigned long) ss->bytes_sent);
+        create_rekey (receiver, ss, &rekey);
+        inject_rekey = GNUNET_YES;
+        payload_len += sizeof (rekey);
+        ss->rekey_initiated = GNUNET_YES;
+      }
+    }
+    if (0 < ss->sequence_used)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Trying to send UDPBox with shared secrect %s sequence_used %u and ss->sequence_allowed %u\n",
+                  GNUNET_h2s (&ss->master),
+                  ss->sequence_used,
+                  ss->sequence_allowed);
+
+    char dgram[payload_len];
+    struct UDPBox *box;
+    gcry_cipher_hd_t out_cipher;
+    size_t dpos;
+
+    box = (struct UDPBox *) dgram;
+    ss->sequence_used++;
+    get_kid (&ss->master, ss->sequence_used, &box->kid);
+    setup_cipher (&ss->master, ss->sequence_used, &out_cipher);
+    /* Append encrypted payload to dgram */
+    dpos = sizeof(struct UDPBox);
+    if (GNUNET_YES == inject_rekey)
+    {
+      GNUNET_assert (
+        0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], sizeof (rekey),
+                                  &rekey, sizeof (rekey)));
+      dpos += sizeof (rekey);
+    }
+    GNUNET_assert (
+      0 == gcry_cipher_encrypt (out_cipher, &dgram[dpos], msize, msg, msize));
+    dpos += msize;
+    do_pad (out_cipher, &dgram[dpos], sizeof(dgram) - dpos);
+    GNUNET_assert (0 == gcry_cipher_gettag (out_cipher,
+                                            box->gcm_tag,
+                                            sizeof(box->gcm_tag)));
+    gcry_cipher_close (out_cipher);
+
+    if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock,
+                                            dgram,
+                                            payload_len, // FIXME why always send sizeof dgram?
+                                            receiver->address,
+                                            receiver->address_len))
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send");
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Sending UDPBox to %s family %d failed sock %p failed\n",
+                  GNUNET_a2s (receiver->address,
+                              receiver->address_len),
+                  receiver->address->sa_family,
+                  udp_sock);
+      receiver_destroy (receiver);
+      return;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending UDPBox with payload size %u, %u acks left, %lu bytes sent\n",
+                msize,
+                receiver->acks_available,
+                (unsigned long) ss->bytes_sent);
+    ss->bytes_sent += sizeof (dgram);
+    receiver->acks_available--;
+    GNUNET_MQ_impl_send_continue (mq);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "No suitable ss found, sending as KX...\n");
+  send_msg_with_kx (msg, receiver, mq);
+}
+
+
+/**
+ * Signature of functions implementing the destruction of a message
+ * queue.  Implementations must not free @a mq, but should take care
+ * of @a impl_state.
+ *
+ * @param mq the message queue to destroy
+ * @param impl_state our `struct ReceiverAddress`
+ */
+static void
+mq_destroy_d (struct GNUNET_MQ_Handle *mq, void *impl_state)
+{
+  struct ReceiverAddress *receiver = impl_state;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Default MQ destroyed\n");
+  if (mq == receiver->d_mq)
+  {
+    receiver->d_mq = NULL;
+    if (GNUNET_YES != receiver->receiver_destroy_called)
+      receiver_destroy (receiver);
+  }
+}
+
+
+/**
+ * Signature of functions implementing the destruction of a message
+ * queue.  Implementations must not free @a mq, but should take care
+ * of @a impl_state.
+ *
+ * @param mq the message queue to destroy
+ * @param impl_state our `struct ReceiverAddress`
+ */
+static void
+mq_destroy_kx (struct GNUNET_MQ_Handle *mq, void *impl_state)
+{
+  struct ReceiverAddress *receiver = impl_state;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "KX MQ destroyed\n");
+  if (mq == receiver->kx_mq)
+  {
+    receiver->kx_mq = NULL;
+    if (GNUNET_YES != receiver->receiver_destroy_called)
+      receiver_destroy (receiver);
+  }
+}
+
+
+/**
+ * Implementation function that cancels the currently sent message.
+ *
+ * @param mq message queue
+ * @param impl_state our `struct RecvierAddress`
+ */
+static void
+mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
+{
+  /* Cancellation is impossible with UDP; bail */
+  GNUNET_assert (0);
+}
+
+
+/**
+ * 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 our `struct ReceiverAddress`
+ * @param error error code
+ */
+static void
+mq_error (void *cls, enum GNUNET_MQ_Error error)
+{
+  struct ReceiverAddress *receiver = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "MQ error in queue to %s: %d\n",
+              GNUNET_i2s (&receiver->target),
+              (int) error);
+  receiver_destroy (receiver);
+}
+
+
+/**
+ * Setup the MQ for the @a receiver.  If a queue exists,
+ * the existing one is destroyed.  Then the MTU is
+ * recalculated and a fresh queue is initialized.
+ *
+ * @param receiver receiver to setup MQ for
+ */
+static void
+setup_receiver_mq (struct ReceiverAddress *receiver)
+{
+  size_t base_mtu;
+
+  switch (receiver->address->sa_family)
+  {
+  case AF_INET:
+    base_mtu = 1480     /* Ethernet MTU, 1500 - Ethernet header - VLAN tag */
+               - sizeof(struct GNUNET_TUN_IPv4Header) /* 20 */
+               - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */;
+    break;
+
+  case AF_INET6:
+    base_mtu = 1280     /* Minimum MTU required by IPv6 */
+               - sizeof(struct GNUNET_TUN_IPv6Header) /* 40 */
+               - sizeof(struct GNUNET_TUN_UdpHeader) /* 8 */;
+    break;
+
+  default:
+    GNUNET_assert (0);
+    break;
+  }
+  /* MTU based on full KX messages */
+  receiver->kx_mtu = base_mtu - sizeof(struct InitialKX)   /* 48 */
+                     - sizeof(struct UDPConfirmation); /* 104 */
+  /* MTU based on BOXed messages */
+  receiver->d_mtu = base_mtu - sizeof(struct UDPBox);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Setting up MQs and QHs\n");
+  /* => Effective MTU for CORE will range from 1080 (IPv6 + KX) to
+     1404 (IPv4 + Box) bytes, depending on circumstances... */
+  if (NULL == receiver->kx_mq)
+    receiver->kx_mq = GNUNET_MQ_queue_for_callbacks (&mq_send_kx,
+                                                     &mq_destroy_kx,
+                                                     &mq_cancel,
+                                                     receiver,
+                                                     NULL,
+                                                     &mq_error,
+                                                     receiver);
+  if (NULL == receiver->d_mq)
+    receiver->d_mq = GNUNET_MQ_queue_for_callbacks (&mq_send_d,
+                                                    &mq_destroy_d,
+                                                    &mq_cancel,
+                                                    receiver,
+                                                    NULL,
+                                                    &mq_error,
+                                                    receiver);
+
+  receiver->kx_qh =
+    GNUNET_TRANSPORT_communicator_mq_add (ch,
+                                          &receiver->target,
+                                          receiver->foreign_addr,
+                                          receiver->kx_mtu,
+                                          GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED,
+                                          0, /* Priority */
+                                          receiver->nt,
+                                          GNUNET_TRANSPORT_CS_OUTBOUND,
+                                          receiver->kx_mq);
+}
+
+
+/**
+ * Function called by the transport service to initialize a
+ * message queue given address information about another peer.
+ * If and when the communication channel is established, the
+ * communicator must call #GNUNET_TRANSPORT_communicator_mq_add()
+ * to notify the service that the channel is now up.  It is
+ * the responsibility of the communicator to manage sane
+ * retries and timeouts for any @a peer/@a address combination
+ * provided by the transport service.  Timeouts and retries
+ * do not need to be signalled to the transport service.
+ *
+ * @param cls closure
+ * @param peer identity of the other peer
+ * @param address where to send the message, human-readable
+ *        communicator-specific format, 0-terminated, UTF-8
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if the provided address is
+ * invalid
+ */
+static int
+mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
+{
+  struct ReceiverAddress *receiver;
+  struct GNUNET_HashContext *hsh;
+  struct GNUNET_HashCode receiver_key;
+  const char *path;
+  struct sockaddr *in;
+  socklen_t in_len;
+
+  if (0 != strncmp (address,
+                    COMMUNICATOR_ADDRESS_PREFIX "-",
+                    strlen (COMMUNICATOR_ADDRESS_PREFIX "-")))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  path = &address[strlen (COMMUNICATOR_ADDRESS_PREFIX "-")];
+  in = udp_address_to_sockaddr (path, &in_len);
+
+  if (NULL == in)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to setup UDP socket address\n");
+    return GNUNET_SYSERR;
+  }
+  if ((AF_INET6 == in->sa_family) &&
+      (GNUNET_YES == disable_v6))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "IPv6 disabled, skipping %s\n", address);
+    GNUNET_free (in);
+    return GNUNET_SYSERR;
+  }
+
+  hsh = GNUNET_CRYPTO_hash_context_start ();
+  GNUNET_CRYPTO_hash_context_read (hsh, in, in_len);
+  GNUNET_CRYPTO_hash_context_read (hsh, peer, sizeof(*peer));
+  GNUNET_CRYPTO_hash_context_finish (hsh, &receiver_key);
+
+  receiver = GNUNET_CONTAINER_multihashmap_get (receivers, &receiver_key);
+  if (NULL != receiver)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "receiver %s already exist or is being connected to\n",
+                address);
+    GNUNET_free (in);
+    return GNUNET_NO;
+  }
+
+  receiver = GNUNET_new (struct ReceiverAddress);
+  receiver->key = receiver_key;
+  receiver->address = in;
+  receiver->address_len = in_len;
+  receiver->target = *peer;
+  receiver->nt = GNUNET_NT_scanner_get_type (is, in, in_len);
+  (void) GNUNET_CONTAINER_multihashmap_put (
+    receivers,
+    &receiver->key,
+    receiver,
+    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Added %s to receivers\n",
+              GNUNET_i2s_full (&receiver->target));
+  receiver->timeout =
+    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+  receiver->hn = GNUNET_CONTAINER_heap_insert (receivers_heap,
+                                               receiver,
+                                               receiver->timeout.abs_value_us);
+  GNUNET_STATISTICS_set (stats,
+                         "# receivers active",
+                         GNUNET_CONTAINER_multihashmap_size (receivers),
+                         GNUNET_NO);
+  receiver->foreign_addr =
+    sockaddr_to_udpaddr_string (receiver->address, receiver->address_len);
+  setup_receiver_mq (receiver);
+  if (NULL == timeout_task)
+    timeout_task = GNUNET_SCHEDULER_add_now (&check_timeouts, NULL);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Iterator over all receivers to clean up.
+ *
+ * @param cls NULL
+ * @param target unused
+ * @param value the queue to destroy
+ * @return #GNUNET_OK to continue to iterate
+ */
+static int
+get_receiver_delete_it (void *cls,
+                        const struct GNUNET_HashCode *target,
+                        void *value)
+{
+  struct ReceiverAddress *receiver = value;
+
+  (void) cls;
+  (void) target;
+  receiver_destroy (receiver);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Iterator over all senders to clean up.
+ *
+ * @param cls NULL
+ * @param target unused
+ * @param value the queue to destroy
+ * @return #GNUNET_OK to continue to iterate
+ */
+static int
+get_sender_delete_it (void *cls,
+                      const struct GNUNET_HashCode *target,
+                      void *value)
+{
+  struct SenderAddress *sender = value;
+
+  (void) cls;
+  (void) target;
+
+
+  sender_destroy (sender);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Shutdown the UNIX communicator.
+ *
+ * @param cls NULL (always)
+ */
+static void
+do_shutdown (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "do_shutdown\n");
+  if (NULL != nat)
+  {
+    GNUNET_NAT_unregister (nat);
+    nat = NULL;
+  }
+  while (NULL != bi_head)
+    bi_destroy (bi_head);
+  if (NULL != broadcast_task)
+  {
+    GNUNET_SCHEDULER_cancel (broadcast_task);
+    broadcast_task = NULL;
+  }
+  if (NULL != timeout_task)
+  {
+    GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = NULL;
+  }
+  if (NULL != read_task)
+  {
+    GNUNET_SCHEDULER_cancel (read_task);
+    read_task = NULL;
+  }
+  if (NULL != udp_sock)
+  {
+    GNUNET_break (GNUNET_OK ==
+                  GNUNET_NETWORK_socket_close (udp_sock));
+    udp_sock = NULL;
+  }
+  GNUNET_CONTAINER_multihashmap_iterate (receivers,
+                                         &get_receiver_delete_it,
+                                         NULL);
+  GNUNET_CONTAINER_multihashmap_destroy (receivers);
+  GNUNET_CONTAINER_multihashmap_iterate (senders,
+                                         &get_sender_delete_it,
+                                         NULL);
+  GNUNET_CONTAINER_multihashmap_destroy (senders);
+  GNUNET_CONTAINER_multishortmap_destroy (key_cache);
+  GNUNET_CONTAINER_heap_destroy (senders_heap);
+  GNUNET_CONTAINER_heap_destroy (receivers_heap);
+  if (NULL != timeout_task)
+  {
+    GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = NULL;
+  }
+  if (NULL != ch)
+  {
+    GNUNET_TRANSPORT_communicator_disconnect (ch);
+    ch = NULL;
+  }
+  if (NULL != ah)
+  {
+    GNUNET_TRANSPORT_application_done (ah);
+    ah = NULL;
+  }
+  if (NULL != stats)
+  {
+    GNUNET_STATISTICS_destroy (stats, GNUNET_YES);
+    stats = NULL;
+  }
+  if (NULL != my_private_key)
+  {
+    GNUNET_free (my_private_key);
+    my_private_key = NULL;
+  }
+  if (NULL != is)
+  {
+    GNUNET_NT_scanner_done (is);
+    is = NULL;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "do_shutdown finished\n");
+}
+
+
+struct AckInfo
+{
+  const struct UDPAck *ack;
+
+  const struct GNUNET_PeerIdentity *sender;
+};
+
+static int
+handle_ack_by_sender (void *cls, const struct GNUNET_HashCode *key, void *value)
+{
+  struct ReceiverAddress *receiver = value;
+  struct AckInfo *ai = cls;
+
+  if (0 != GNUNET_memcmp (ai->sender, &receiver->target))
+  {
+    return GNUNET_YES;
+  }
+  handle_ack ((void*) ai->ack, key, receiver);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Function called when the transport service has received a
+ * backchannel message for this communicator (!) via a different return
+ * path. Should be an acknowledgement.
+ *
+ * @param cls closure, NULL
+ * @param sender which peer sent the notification
+ * @param msg payload
+ */
+static void
+enc_notify_cb (void *cls,
+               const struct GNUNET_PeerIdentity *sender,
+               const struct GNUNET_MessageHeader *msg)
+{
+  struct AckInfo ai;
+
+  (void) cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Storing UDPAck received from backchannel from %s\n",
+              GNUNET_i2s_full (sender));
+  if ((ntohs (msg->type) != GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK) ||
+      (ntohs (msg->size) != sizeof(struct UDPAck)))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  ai.ack = (const struct UDPAck *) msg;
+  ai.sender = sender;
+  GNUNET_CONTAINER_multihashmap_iterate (receivers,
+                                         &handle_ack_by_sender,
+                                         &ai);
+}
+
+
+/**
+ * Signature of the callback passed to #GNUNET_NAT_register() for
+ * a function to call whenever our set of 'valid' addresses changes.
+ *
+ * @param cls closure
+ * @param app_ctx[in,out] location where the app can store stuff
+ *                  on add and retrieve it on remove
+ * @param add_remove #GNUNET_YES to add a new public IP address,
+ *                   #GNUNET_NO to remove a previous (now invalid) one
+ * @param ac address class the address belongs to
+ * @param addr either the previous or the new public IP address
+ * @param addrlen actual length of the @a addr
+ */
+static void
+nat_address_cb (void *cls,
+                void **app_ctx,
+                int add_remove,
+                enum GNUNET_NAT_AddressClass ac,
+                const struct sockaddr *addr,
+                socklen_t addrlen)
+{
+  char *my_addr;
+  struct GNUNET_TRANSPORT_AddressIdentifier *ai;
+
+  if (GNUNET_YES == add_remove)
+  {
+    enum GNUNET_NetworkType nt;
+
+    GNUNET_asprintf (&my_addr,
+                     "%s-%s",
+                     COMMUNICATOR_ADDRESS_PREFIX,
+                     GNUNET_a2s (addr, addrlen));
+    nt = GNUNET_NT_scanner_get_type (is, addr, addrlen);
+    ai =
+      GNUNET_TRANSPORT_communicator_address_add (ch,
+                                                 my_addr,
+                                                 nt,
+                                                 GNUNET_TIME_UNIT_FOREVER_REL);
+    GNUNET_free (my_addr);
+    *app_ctx = ai;
+  }
+  else
+  {
+    ai = *app_ctx;
+    GNUNET_TRANSPORT_communicator_address_remove (ai);
+    *app_ctx = NULL;
+  }
+}
+
+
+/**
+ * Broadcast our presence on one of our interfaces.
+ *
+ * @param cls a `struct BroadcastInterface`
+ */
+static void
+ifc_broadcast (void *cls)
+{
+  struct BroadcastInterface *bi = cls;
+  struct GNUNET_TIME_Relative delay;
+
+  delay = BROADCAST_FREQUENCY;
+  delay.rel_value_us =
+    GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, delay.rel_value_us);
+  bi->broadcast_task =
+    GNUNET_SCHEDULER_add_delayed (delay, &ifc_broadcast, bi);
+
+  switch (bi->sa->sa_family)
+  {
+  case AF_INET: {
+      static int yes = 1;
+      static int no = 0;
+      ssize_t sent;
+
+      if (GNUNET_OK !=
+          GNUNET_NETWORK_socket_setsockopt (udp_sock,
+                                            SOL_SOCKET,
+                                            SO_BROADCAST,
+                                            &yes,
+                                            sizeof(int)))
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
+                             "setsockopt");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "creating UDPBroadcast from %s\n",
+                  GNUNET_i2s (&(bi->bcm.sender)));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "sending UDPBroadcast to add %s\n",
+                  GNUNET_a2s (bi->ba, bi->salen));
+      sent = GNUNET_NETWORK_socket_sendto (udp_sock,
+                                           &bi->bcm,
+                                           sizeof(bi->bcm),
+                                           bi->ba,
+                                           bi->salen);
+      if (-1 == sent)
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
+                             "sendto");
+      if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock,
+                                                         SOL_SOCKET,
+                                                         SO_BROADCAST,
+                                                         &no,
+                                                         sizeof(int)))
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
+                             "setsockopt");
+      break;
+    }
+
+  case AF_INET6: {
+      ssize_t sent;
+      struct sockaddr_in6 dst;
+
+      dst.sin6_family = AF_INET6;
+      dst.sin6_port = htons (my_port);
+      dst.sin6_addr = bi->mcreq.ipv6mr_multiaddr;
+      dst.sin6_scope_id = ((struct sockaddr_in6 *) bi->ba)->sin6_scope_id;
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "sending UDPBroadcast\n");
+      sent = GNUNET_NETWORK_socket_sendto (udp_sock,
+                                           &bi->bcm,
+                                           sizeof(bi->bcm),
+                                           (const struct sockaddr *) &dst,
+                                           sizeof(dst));
+      if (-1 == sent)
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "sendto");
+      break;
+    }
+
+  default:
+    GNUNET_break (0);
+    break;
+  }
+}
+
+
+/**
+ * Callback function invoked for each interface found.
+ * Activates/deactivates broadcast interfaces.
+ *
+ * @param cls NULL
+ * @param name name of the interface (can be NULL for unknown)
+ * @param isDefault is this presumably the default interface
+ * @param addr address of this interface (can be NULL for unknown or unassigned)
+ * @param broadcast_addr the broadcast address (can be NULL for unknown or
+ * unassigned)
+ * @param netmask the network mask (can be NULL for unknown or unassigned)
+ * @param addrlen length of the address
+ * @return #GNUNET_OK to continue iteration, #GNUNET_SYSERR to abort
+ */
+static int
+iface_proc (void *cls,
+            const char *name,
+            int isDefault,
+            const struct sockaddr *addr,
+            const struct sockaddr *broadcast_addr,
+            const struct sockaddr *netmask,
+            socklen_t addrlen)
+{
+  struct BroadcastInterface *bi;
+  enum GNUNET_NetworkType network;
+  struct UdpBroadcastSignature ubs;
+
+  (void) cls;
+  (void) netmask;
+  if (NULL == addr)
+    return GNUNET_YES; /* need to know our address! */
+  network = GNUNET_NT_scanner_get_type (is, addr, addrlen);
+  if (GNUNET_NT_LOOPBACK == network)
+  {
+    /* Broadcasting on loopback does not make sense */
+    return GNUNET_YES;
+  }
+  for (bi = bi_head; NULL != bi; bi = bi->next)
+  {
+    if ((bi->salen == addrlen) && (0 == memcmp (addr, bi->sa, addrlen)))
+    {
+      bi->found = GNUNET_YES;
+      return GNUNET_OK;
+    }
+  }
+
+  if ((AF_INET6 == addr->sa_family) && (NULL == broadcast_addr))
+    return GNUNET_OK; /* broadcast_addr is required for IPv6! */
+  if ((AF_INET6 == addr->sa_family) && (GNUNET_YES != have_v6_socket))
+    return GNUNET_OK; /* not using IPv6 */
+
+  bi = GNUNET_new (struct BroadcastInterface);
+  bi->sa = GNUNET_memdup (addr,
+                          addrlen);
+  if ( (NULL != broadcast_addr) &&
+       (addrlen == sizeof (struct sockaddr_in)) )
+  {
+    struct sockaddr_in *ba;
+
+    ba = GNUNET_memdup (broadcast_addr,
+                        addrlen);
+    ba->sin_port = htons (2086); /* always GNUnet port, ignore configuration! */
+    bi->ba = (struct sockaddr *) ba;
+  }
+  bi->salen = addrlen;
+  bi->found = GNUNET_YES;
+  bi->bcm.sender = my_identity;
+  ubs.purpose.purpose = htonl (
+    GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_UDP_BROADCAST);
+  ubs.purpose.size = htonl (sizeof(ubs));
+  ubs.sender = my_identity;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "creating UDPBroadcastSignature for %s\n",
+              GNUNET_a2s (addr, addrlen));
+  GNUNET_CRYPTO_hash (addr, addrlen, &ubs.h_address);
+  GNUNET_CRYPTO_eddsa_sign (my_private_key,
+                            &ubs,
+                            &bi->bcm.sender_sig);
+  if (NULL != bi->ba)
+  {
+    bi->broadcast_task = GNUNET_SCHEDULER_add_now (&ifc_broadcast, bi);
+    GNUNET_CONTAINER_DLL_insert (bi_head, bi_tail, bi);
+  }
+  if ((AF_INET6 == addr->sa_family) && (NULL != broadcast_addr))
+  {
+    /* Create IPv6 multicast request */
+    const struct sockaddr_in6 *s6 =
+      (const struct sockaddr_in6 *) broadcast_addr;
+
+    GNUNET_assert (
+      1 == inet_pton (AF_INET6, "FF05::13B", &bi->mcreq.ipv6mr_multiaddr));
+
+    /* http://tools.ietf.org/html/rfc2553#section-5.2:
+     *
+     * IPV6_JOIN_GROUP
+     *
+     * Join a multicast group on a specified local interface.  If the
+     * interface index is specified as 0, the kernel chooses the local
+     * interface.  For example, some kernels look up the multicast
+     * group in the normal IPv6 routing table and using the resulting
+     * interface; we do this for each interface, so no need to use
+     * zero (anymore...).
+     */
+    bi->mcreq.ipv6mr_interface = s6->sin6_scope_id;
+
+    /* Join the multicast group */
+    if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (udp_sock,
+                                                       IPPROTO_IPV6,
+                                                       IPV6_JOIN_GROUP,
+                                                       &bi->mcreq,
+                                                       sizeof(bi->mcreq)))
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "setsockopt");
+    }
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Scan interfaces to broadcast our presence on the LAN.
+ *
+ * @param cls NULL, unused
+ */
+static void
+do_broadcast (void *cls)
+{
+  struct BroadcastInterface *bin;
+
+  (void) cls;
+  for (struct BroadcastInterface *bi = bi_head; NULL != bi; bi = bi->next)
+    bi->found = GNUNET_NO;
+  GNUNET_OS_network_interfaces_list (&iface_proc, NULL);
+  for (struct BroadcastInterface *bi = bi_head; NULL != bi; bi = bin)
+  {
+    bin = bi->next;
+    if (GNUNET_NO == bi->found)
+      bi_destroy (bi);
+  }
+  broadcast_task = GNUNET_SCHEDULER_add_delayed (INTERFACE_SCAN_FREQUENCY,
+                                                 &do_broadcast,
+                                                 NULL);
+}
+
+
+static void
+try_connection_reversal (void *cls,
+                         const struct sockaddr *addr,
+                         socklen_t addrlen)
+{
+  /* FIXME: support reversal: #5529 */
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "No connection reversal implemented!");
+}
+
+
+/**
+ * Setup communicator and launch network interactions.
+ *
+ * @param cls NULL (always)
+ * @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)
+{
+  char *bindto;
+  struct sockaddr *in;
+  socklen_t in_len;
+  struct sockaddr_storage in_sto;
+  socklen_t sto_len;
+
+  (void) cls;
+  cfg = c;
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             COMMUNICATOR_CONFIG_SECTION,
+                                             "BINDTO",
+                                             &bindto))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               COMMUNICATOR_CONFIG_SECTION,
+                               "BINDTO");
+    return;
+  }
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_time (cfg,
+                                           COMMUNICATOR_CONFIG_SECTION,
+                                           "REKEY_INTERVAL",
+                                           &rekey_interval))
+    rekey_interval = DEFAULT_REKEY_TIME_INTERVAL;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_size (cfg,
+                                           COMMUNICATOR_CONFIG_SECTION,
+                                           "REKEY_MAX_BYTES",
+                                           &rekey_max_bytes))
+  {
+    rekey_max_bytes = DEFAULT_REKEY_MAX_BYTES;
+  }
+  disable_v6 = GNUNET_NO;
+  if ((GNUNET_NO == GNUNET_NETWORK_test_pf (PF_INET6)) ||
+      (GNUNET_YES ==
+       GNUNET_CONFIGURATION_get_value_yesno (cfg,
+                                             COMMUNICATOR_CONFIG_SECTION,
+                                             "DISABLE_V6")))
+  {
+    disable_v6 = GNUNET_YES;
+  }
+
+  in = udp_address_to_sockaddr (bindto, &in_len);
+  if (NULL == in)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to setup UDP socket address with path `%s'\n",
+                bindto);
+    GNUNET_free (bindto);
+    return;
+  }
+  udp_sock =
+    GNUNET_NETWORK_socket_create (in->sa_family,
+                                  SOCK_DGRAM,
+                                  IPPROTO_UDP);
+  if (NULL == udp_sock)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to create socket for %s family %d\n",
+                GNUNET_a2s (in,
+                            in_len),
+                in->sa_family);
+    GNUNET_free (in);
+    GNUNET_free (bindto);
+    return;
+  }
+  if (AF_INET6 == in->sa_family)
+    have_v6_socket = GNUNET_YES;
+  if (GNUNET_OK !=
+      GNUNET_NETWORK_socket_bind (udp_sock,
+                                  in,
+                                  in_len))
+  {
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
+                              "bind",
+                              bindto);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to bind socket for %s family %d sock %p\n",
+                GNUNET_a2s (in,
+                            in_len),
+                in->sa_family,
+                udp_sock);
+    GNUNET_NETWORK_socket_close (udp_sock);
+    udp_sock = NULL;
+    GNUNET_free (in);
+    GNUNET_free (bindto);
+    return;
+  }
+
+  /* We might have bound to port 0, allowing the OS to figure it out;
+     thus, get the real IN-address from the socket */
+  sto_len = sizeof(in_sto);
+  if (0 != getsockname (GNUNET_NETWORK_get_fd (udp_sock),
+                        (struct sockaddr *) &in_sto,
+                        &sto_len))
+  {
+    memcpy (&in_sto, in, in_len);
+    sto_len = in_len;
+  }
+  GNUNET_free (in);
+  GNUNET_free (bindto);
+  in = (struct sockaddr *) &in_sto;
+  in_len = sto_len;
+  GNUNET_log_from_nocheck (GNUNET_ERROR_TYPE_INFO,
+                           "transport",
+                           "Bound to `%s' sock %p\n",
+                           GNUNET_a2s ((const struct sockaddr *) &in_sto,
+                                       sto_len),
+                           udp_sock);
+  switch (in->sa_family)
+  {
+  case AF_INET:
+    my_port = ntohs (((struct sockaddr_in *) in)->sin_port);
+    break;
+
+  case AF_INET6:
+    my_port = ntohs (((struct sockaddr_in6 *) in)->sin6_port);
+    break;
+
+  default:
+    GNUNET_break (0);
+    my_port = 0;
+  }
+  stats = GNUNET_STATISTICS_create ("communicator-udp", cfg);
+  senders = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_YES);
+  receivers = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_YES);
+  senders_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+  receivers_heap =
+    GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+  key_cache = GNUNET_CONTAINER_multishortmap_create (1024, GNUNET_YES);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+  is = GNUNET_NT_scanner_init ();
+  my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
+  if (NULL == my_private_key)
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_ERROR,
+      _ (
+        "Transport service is lacking key configuration settings. Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key);
+  /* start reading */
+  read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                             udp_sock,
+                                             &sock_read,
+                                             NULL);
+  ch = GNUNET_TRANSPORT_communicator_connect (cfg,
+                                              COMMUNICATOR_CONFIG_SECTION,
+                                              COMMUNICATOR_ADDRESS_PREFIX,
+                                              GNUNET_TRANSPORT_CC_UNRELIABLE,
+                                              &mq_init,
+                                              NULL,
+                                              &enc_notify_cb,
+                                              NULL);
+  if (NULL == ch)
+  {
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  ah = GNUNET_TRANSPORT_application_init (cfg);
+  if (NULL == ah)
+  {
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  /* start broadcasting */
+  if (GNUNET_YES !=
+      GNUNET_CONFIGURATION_get_value_yesno (cfg,
+                                            COMMUNICATOR_CONFIG_SECTION,
+                                            "DISABLE_BROADCAST"))
+  {
+    broadcast_task = GNUNET_SCHEDULER_add_now (&do_broadcast, NULL);
+  }
+  nat = GNUNET_NAT_register (cfg,
+                             COMMUNICATOR_CONFIG_SECTION,
+                             IPPROTO_UDP,
+                             1 /* one address */,
+                             (const struct sockaddr **) &in,
+                             &in_len,
+                             &nat_address_cb,
+                             try_connection_reversal,
+                             NULL /* closure */);
+}
+
+
+/**
+ * The main function for the UNIX communicator.
+ *
+ * @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
+  };
+  int ret;
+
+  GNUNET_log_from_nocheck (GNUNET_ERROR_TYPE_DEBUG,
+                           "transport",
+                           "Starting udp communicator\n");
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
+    return 2;
+
+  ret = (GNUNET_OK == GNUNET_PROGRAM_run (argc,
+                                          argv,
+                                          "gnunet-communicator-udp",
+                                          _ ("GNUnet UDP communicator"),
+                                          options,
+                                          &run,
+                                          NULL))
+        ? 0
+        : 1;
+  GNUNET_free_nz ((void *) argv);
+  return ret;
+}
+
+
+/* end of gnunet-communicator-udp.c */
diff --git a/src/service/transport/gnunet-communicator-unix.c b/src/service/transport/gnunet-communicator-unix.c
new file mode 100644
index 000000000..1cdc85b8a
--- /dev/null
+++ b/src/service/transport/gnunet-communicator-unix.c
@@ -0,0 +1,1166 @@
+/*
+     This file is part of GNUnet
+     Copyright (C) 2010-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 transport/gnunet-communicator-unix.c
+ * @brief Transport plugin using unix domain sockets (!)
+ *        Clearly, can only be used locally on Unix/Linux hosts...
+ *        ONLY INTENDED FOR TESTING!!!
+ * @author Christian Grothoff
+ * @author Nathan Evans
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_constants.h"
+#include "gnunet_statistics_service.h"
+#include "gnunet_transport_communication_service.h"
+
+/**
+ * How many messages do we keep at most in the queue to the
+ * transport service before we start to drop (default,
+ * can be changed via the configuration file).
+ * Should be _below_ the level of the communicator API, as
+ * otherwise we may read messages just to have them dropped
+ * by the communicator API.
+ */
+#define DEFAULT_MAX_QUEUE_LENGTH 8000
+
+/**
+ * Address prefix used by the communicator.
+ */
+#define COMMUNICATOR_ADDRESS_PREFIX "unix"
+
+/**
+ * Configuration section used by the communicator.
+ */
+#define COMMUNICATOR_CONFIG_SECTION "communicator-unix"
+
+/**
+ * Our MTU.
+ */
+#ifndef DARWIN
+#define UNIX_MTU UINT16_MAX
+#else
+#define UNIX_MTU 2048
+#endif
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * UNIX Message-Packet header.
+ */
+struct UNIXMessage
+{
+  /**
+   * Message header.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * What is the identity of the sender (GNUNET_hash of public key)
+   */
+  struct GNUNET_PeerIdentity sender;
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+
+/**
+ * Handle for a queue.
+ */
+struct Queue
+{
+  /**
+   * Queues with pending messages (!) are kept in a DLL.
+   */
+  struct Queue *next;
+
+  /**
+   * Queues with pending messages (!) are kept in a DLL.
+   */
+  struct Queue *prev;
+
+  /**
+   * To whom are we talking to.
+   */
+  struct GNUNET_PeerIdentity target;
+
+  /**
+   * Address of the other peer.
+   */
+  struct sockaddr_un *address;
+
+  /**
+   * Length of the address.
+   */
+  socklen_t address_len;
+
+  /**
+   * Message currently scheduled for transmission, non-NULL if and only
+   * if this queue is in the #queue_head DLL.
+   */
+  struct UNIXMessage *msg;
+
+  /**
+   * Message queue we are providing for the #ch.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * handle for this queue with the #ch.
+   */
+  struct GNUNET_TRANSPORT_QueueHandle *qh;
+
+  /**
+   * Number of bytes we currently have in our write queue.
+   */
+  unsigned long long bytes_in_queue;
+
+  /**
+   * Timeout for this queue.
+   */
+  struct GNUNET_TIME_Absolute timeout;
+
+  /**
+   * Queue timeout task.
+   */
+  struct GNUNET_SCHEDULER_Task *timeout_task;
+};
+
+/**
+ * My Peer Identity
+ */
+static struct GNUNET_PeerIdentity my_identity;
+
+/**
+ * ID of read task
+ */
+static struct GNUNET_SCHEDULER_Task *read_task;
+
+/**
+ * ID of write task
+ */
+static struct GNUNET_SCHEDULER_Task *write_task;
+
+/**
+ * Number of messages we currently have in our queues towards the transport service.
+ */
+static unsigned long long delivering_messages;
+
+/**
+ * Maximum queue length before we stop reading towards the transport service.
+ */
+static unsigned long long max_queue_length;
+
+/**
+ * For logging statistics.
+ */
+static struct GNUNET_STATISTICS_Handle *stats;
+
+/**
+ * Our environment.
+ */
+static struct GNUNET_TRANSPORT_CommunicatorHandle *ch;
+
+/**
+ * Queues (map from peer identity to `struct Queue`)
+ */
+static struct GNUNET_CONTAINER_MultiPeerMap *queue_map;
+
+/**
+ * Head of queue of messages to transmit.
+ */
+static struct Queue *queue_head;
+
+/**
+ * Tail of queue of messages to transmit.
+ */
+static struct Queue *queue_tail;
+
+/**
+ * socket that we transmit all data with
+ */
+static struct GNUNET_NETWORK_Handle *unix_sock;
+
+/**
+ * Handle to the operation that publishes our address.
+ */
+static struct GNUNET_TRANSPORT_AddressIdentifier *ai;
+
+
+/**
+ * Functions with this signature are called whenever we need
+ * to close a queue due to a disconnect or failure to
+ * establish a connection.
+ *
+ * @param queue queue to close down
+ */
+static void
+queue_destroy (struct Queue *queue)
+{
+  struct GNUNET_MQ_Handle *mq;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Disconnecting queue for peer `%s'\n",
+              GNUNET_i2s (&queue->target));
+  if (0 != queue->bytes_in_queue)
+  {
+    GNUNET_CONTAINER_DLL_remove (queue_head, queue_tail, queue);
+    queue->bytes_in_queue = 0;
+  }
+  if (NULL != (mq = queue->mq))
+  {
+    queue->mq = NULL;
+    GNUNET_MQ_destroy (mq);
+  }
+  GNUNET_assert (
+    GNUNET_YES ==
+    GNUNET_CONTAINER_multipeermap_remove (queue_map, &queue->target, queue));
+  GNUNET_STATISTICS_set (stats,
+                         "# queues active",
+                         GNUNET_CONTAINER_multipeermap_size (queue_map),
+                         GNUNET_NO);
+  if (NULL != queue->timeout_task)
+  {
+    GNUNET_SCHEDULER_cancel (queue->timeout_task);
+    queue->timeout_task = NULL;
+  }
+  GNUNET_free (queue->address);
+  GNUNET_free (queue);
+}
+
+
+/**
+ * Queue was idle for too long, so disconnect it
+ *
+ * @param cls the `struct Queue *` to disconnect
+ */
+static void
+queue_timeout (void *cls)
+{
+  struct Queue *queue = cls;
+  struct GNUNET_TIME_Relative left;
+
+  queue->timeout_task = NULL;
+  left = GNUNET_TIME_absolute_get_remaining (queue->timeout);
+  if (0 != left.rel_value_us)
+  {
+    /* not actually our turn yet, but let's at least update
+       the monitor, it may think we're about to die ... */
+    queue->timeout_task =
+      GNUNET_SCHEDULER_add_delayed (left, &queue_timeout, queue);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Queue %p was idle for %s, disconnecting\n",
+              queue,
+              GNUNET_STRINGS_relative_time_to_string (
+                GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+                GNUNET_YES));
+  queue_destroy (queue);
+}
+
+
+/**
+ * Increment queue timeout due to activity.  We do not immediately
+ * notify the monitor here as that might generate excessive
+ * signalling.
+ *
+ * @param queue queue for which the timeout should be rescheduled
+ */
+static void
+reschedule_queue_timeout (struct Queue *queue)
+{
+  GNUNET_assert (NULL != queue->timeout_task);
+  queue->timeout =
+    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+}
+
+
+/**
+ * Convert unix path to a `struct sockaddr_un *`
+ *
+ * @param unixpath path to convert
+ * @param[out] sock_len set to the length of the address
+ * @param is_abstract is this an abstract @a unixpath
+ * @return converted unix path
+ */
+static struct sockaddr_un *
+unix_address_to_sockaddr (const char *unixpath, socklen_t *sock_len)
+{
+  struct sockaddr_un *un;
+  size_t slen;
+
+  GNUNET_assert (0 < strlen (unixpath));   /* sanity check */
+  un = GNUNET_new (struct sockaddr_un);
+  un->sun_family = AF_UNIX;
+  slen = strlen (unixpath);
+  if (slen >= sizeof(un->sun_path))
+    slen = sizeof(un->sun_path) - 1;
+  GNUNET_memcpy (un->sun_path, unixpath, slen);
+  un->sun_path[slen] = '\0';
+  slen = sizeof(struct sockaddr_un);
+#if HAVE_SOCKADDR_UN_SUN_LEN
+  un->sun_len = (u_char) slen;
+#endif
+  (*sock_len) = slen;
+  if ('@' == un->sun_path[0])
+    un->sun_path[0] = '\0';
+  return un;
+}
+
+
+/**
+ * Closure to #lookup_queue_it().
+ */
+struct LookupCtx
+{
+  /**
+   * Location to store the queue, if found.
+   */
+  struct Queue *res;
+
+  /**
+   * Address we are looking for.
+   */
+  const struct sockaddr_un *un;
+
+  /**
+   * Number of bytes in @a un
+   */
+  socklen_t un_len;
+};
+
+
+/**
+ * Function called to find a queue by address.
+ *
+ * @param cls the `struct LookupCtx *`
+ * @param key peer we are looking for (unused)
+ * @param value a queue
+ * @return #GNUNET_YES if not found (continue looking), #GNUNET_NO on success
+ */
+static int
+lookup_queue_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
+{
+  struct LookupCtx *lctx = cls;
+  struct Queue *queue = value;
+
+  if ((queue->address_len == lctx->un_len) &&
+      (0 == memcmp (lctx->un, queue->address, queue->address_len)))
+  {
+    lctx->res = queue;
+    return GNUNET_NO;
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * Find an existing queue by address.
+ *
+ * @param plugin the plugin
+ * @param address the address to find
+ * @return NULL if queue was not found
+ */
+static struct Queue *
+lookup_queue (const struct GNUNET_PeerIdentity *peer,
+              const struct sockaddr_un *un,
+              socklen_t un_len)
+{
+  struct LookupCtx lctx;
+
+  lctx.un = un;
+  lctx.un_len = un_len;
+  lctx.res = NULL;
+  GNUNET_CONTAINER_multipeermap_get_multiple (queue_map,
+                                              peer,
+                                              &lookup_queue_it,
+                                              &lctx);
+  return lctx.res;
+}
+
+
+/**
+ * We have been notified that our socket is ready to write.
+ * Then reschedule this function to be called again once more is available.
+ *
+ * @param cls NULL
+ */
+static void
+select_write_cb (void *cls)
+{
+  struct Queue *queue = queue_tail;
+  const struct GNUNET_MessageHeader *msg = &queue->msg->header;
+  size_t msg_size = ntohs (msg->size);
+  ssize_t sent;
+
+  /* take queue of the ready list */
+  write_task = NULL;
+resend:
+  /* Send the data */
+  sent = GNUNET_NETWORK_socket_sendto (unix_sock,
+                                       msg,
+                                       msg_size,
+                                       (const struct sockaddr *) queue->address,
+                                       queue->address_len);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "UNIX transmitted message to %s (%d/%u: %s)\n",
+              GNUNET_i2s (&queue->target),
+              (int) sent,
+              (unsigned int) msg_size,
+              (sent < 0) ? strerror (errno) : "ok");
+  if (-1 != sent)
+  {
+    GNUNET_CONTAINER_DLL_remove (queue_head, queue_tail, queue);
+    if (NULL != queue_head)
+      write_task = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                                   unix_sock,
+                                                   &select_write_cb,
+                                                   NULL);
+
+    /* send 'msg' */
+    GNUNET_free (queue->msg);
+    queue->msg = NULL;
+    GNUNET_MQ_impl_send_continue (queue->mq);
+    GNUNET_STATISTICS_update (stats,
+                              "# bytes sent",
+                              (long long) sent,
+                              GNUNET_NO);
+    reschedule_queue_timeout (queue);
+    return;   /* all good */
+  }
+  GNUNET_STATISTICS_update (stats,
+                            "# network transmission failures",
+                            1,
+                            GNUNET_NO);
+  write_task = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                               unix_sock,
+                                               &select_write_cb,
+                                               NULL);
+  switch (errno)
+  {
+  case EAGAIN:
+  case ENOBUFS:
+    /* We should retry later... */
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "send");
+    return;
+
+  case EMSGSIZE: {
+      socklen_t size = 0;
+      socklen_t len = sizeof(size);
+
+      GNUNET_NETWORK_socket_getsockopt (unix_sock,
+                                        SOL_SOCKET,
+                                        SO_SNDBUF,
+                                        &size,
+                                        &len);
+      if (size > ntohs (msg->size))
+      {
+        /* Buffer is bigger than message:  error, no retry
+         * This should never happen!*/
+        GNUNET_break (0);
+        return;
+      }
+      GNUNET_log (
+        GNUNET_ERROR_TYPE_WARNING,
+        "Trying to increase socket buffer size from %u to %u for message size %u\n",
+        (unsigned int) size,
+        (unsigned int) ((msg_size / 1000) + 2) * 1000,
+        (unsigned int) msg_size);
+      size = ((msg_size / 1000) + 2) * 1000;
+      if (GNUNET_OK == GNUNET_NETWORK_socket_setsockopt (unix_sock,
+                                                         SOL_SOCKET,
+                                                         SO_SNDBUF,
+                                                         &size,
+                                                         sizeof(size)))
+        goto resend; /* Increased buffer size, retry sending */
+      /* Ok, then just try very modest increase */
+      size = msg_size;
+      if (GNUNET_OK == GNUNET_NETWORK_socket_setsockopt (unix_sock,
+                                                         SOL_SOCKET,
+                                                         SO_SNDBUF,
+                                                         &size,
+                                                         sizeof(size)))
+        goto resend; /* Increased buffer size, retry sending */
+      /* Could not increase buffer size: error, no retry */
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "setsockopt");
+      return;
+    }
+
+  default:
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "send");
+    return;
+  }
+}
+
+
+/**
+ * Signature of functions implementing the sending functionality of a
+ * message queue.
+ *
+ * @param mq the message queue
+ * @param msg the message to send
+ * @param impl_state our `struct Queue`
+ */
+static void
+mq_send (struct GNUNET_MQ_Handle *mq,
+         const struct GNUNET_MessageHeader *msg,
+         void *impl_state)
+{
+  struct Queue *queue = impl_state;
+  size_t msize = ntohs (msg->size);
+
+  GNUNET_assert (mq == queue->mq);
+  GNUNET_assert (NULL == queue->msg);
+  // Convert to UNIXMessage
+  queue->msg = GNUNET_malloc (msize + sizeof (struct UNIXMessage));
+  queue->msg->header.size = htons (msize + sizeof (struct UNIXMessage));
+  queue->msg->sender = my_identity;
+  memcpy (&queue->msg[1], msg, msize);
+  GNUNET_CONTAINER_DLL_insert (queue_head, queue_tail, queue);
+  GNUNET_assert (NULL != unix_sock);
+  if (NULL == write_task)
+    write_task = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                                 unix_sock,
+                                                 &select_write_cb,
+                                                 NULL);
+}
+
+
+/**
+ * Signature of functions implementing the destruction of a message
+ * queue.  Implementations must not free @a mq, but should take care
+ * of @a impl_state.
+ *
+ * @param mq the message queue to destroy
+ * @param impl_state our `struct Queue`
+ */
+static void
+mq_destroy (struct GNUNET_MQ_Handle *mq, void *impl_state)
+{
+  struct Queue *queue = impl_state;
+
+  if (mq == queue->mq)
+  {
+    queue->mq = NULL;
+    queue_destroy (queue);
+  }
+}
+
+
+/**
+ * Implementation function that cancels the currently sent message.
+ *
+ * @param mq message queue
+ * @param impl_state our `struct Queue`
+ */
+static void
+mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
+{
+  struct Queue *queue = impl_state;
+
+  GNUNET_assert (NULL != queue->msg);
+  queue->msg = NULL;
+  GNUNET_CONTAINER_DLL_remove (queue_head, queue_tail, queue);
+  GNUNET_assert (NULL != write_task);
+  if (NULL == queue_head)
+  {
+    GNUNET_SCHEDULER_cancel (write_task);
+    write_task = NULL;
+  }
+}
+
+
+/**
+ * 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 our `struct Queue`
+ * @param error error code
+ */
+static void
+mq_error (void *cls, enum GNUNET_MQ_Error error)
+{
+  struct Queue *queue = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "UNIX MQ error in queue to %s: %d\n",
+              GNUNET_i2s (&queue->target),
+              (int) error);
+  queue_destroy (queue);
+}
+
+
+/**
+ * Creates a new outbound queue the transport service will use to send
+ * data to another peer.
+ *
+ * @param peer the target peer
+ * @param cs inbound or outbound queue
+ * @param un the address
+ * @param un_len number of bytes in @a un
+ * @return the queue or NULL of max connections exceeded
+ */
+static struct Queue *
+setup_queue (const struct GNUNET_PeerIdentity *target,
+             enum GNUNET_TRANSPORT_ConnectionStatus cs,
+             const struct sockaddr_un *un,
+             socklen_t un_len)
+{
+  struct Queue *queue;
+
+  queue = GNUNET_new (struct Queue);
+  queue->target = *target;
+  queue->address = GNUNET_memdup (un, un_len);
+  queue->address_len = un_len;
+  (void) GNUNET_CONTAINER_multipeermap_put (
+    queue_map,
+    &queue->target,
+    queue,
+    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  GNUNET_STATISTICS_set (stats,
+                         "# queues active",
+                         GNUNET_CONTAINER_multipeermap_size (queue_map),
+                         GNUNET_NO);
+  queue->timeout =
+    GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
+  queue->timeout_task =
+    GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
+                                  &queue_timeout,
+                                  queue);
+  queue->mq = GNUNET_MQ_queue_for_callbacks (&mq_send,
+                                             &mq_destroy,
+                                             &mq_cancel,
+                                             queue,
+                                             NULL,
+                                             &mq_error,
+                                             queue);
+  {
+    char *foreign_addr;
+
+    if ('\0' == un->sun_path[0])
+      GNUNET_asprintf (&foreign_addr,
+                       "%s-@%s",
+                       COMMUNICATOR_ADDRESS_PREFIX,
+                       &un->sun_path[1]);
+    else
+      GNUNET_asprintf (&foreign_addr,
+                       "%s-%s",
+                       COMMUNICATOR_ADDRESS_PREFIX,
+                       un->sun_path);
+    queue->qh = GNUNET_TRANSPORT_communicator_mq_add (ch,
+                                                      &queue->target,
+                                                      foreign_addr,
+                                                      UNIX_MTU - sizeof (struct
+                                                                         UNIXMessage),
+                                                      GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED,
+                                                      0,
+                                                      GNUNET_NT_LOOPBACK,
+                                                      cs,
+                                                      queue->mq);
+    GNUNET_free (foreign_addr);
+  }
+  return queue;
+}
+
+
+/**
+ * We have been notified that our socket has something to read. Do the
+ * read and reschedule this function to be called again once more is
+ * available.
+ *
+ * @param cls NULL
+ */
+static void
+select_read_cb (void *cls);
+
+
+/**
+ * Function called when message was successfully passed to
+ * transport service.  Continue read activity.
+ *
+ * @param cls NULL
+ * @param success #GNUNET_OK on success
+ */
+static void
+receive_complete_cb (void *cls, int success)
+{
+  (void) cls;
+  delivering_messages--;
+  if (GNUNET_OK != success)
+    GNUNET_STATISTICS_update (stats,
+                              "# transport transmission failures",
+                              1,
+                              GNUNET_NO);
+  if ((NULL == read_task) && (delivering_messages < max_queue_length) &&
+      (NULL != unix_sock))
+    read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                               unix_sock,
+                                               &select_read_cb,
+                                               NULL);
+}
+
+
+/**
+ * We have been notified that our socket has something to read. Do the
+ * read and reschedule this function to be called again once more is
+ * available.
+ *
+ * @param cls NULL
+ */
+static void
+select_read_cb (void *cls)
+{
+  char buf[65536] GNUNET_ALIGN;
+  struct Queue *queue;
+  const struct UNIXMessage *msg;
+  struct sockaddr_un un;
+  socklen_t addrlen;
+  ssize_t ret;
+  uint16_t msize;
+
+  GNUNET_assert (NULL != unix_sock);
+  read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                             unix_sock,
+                                             &select_read_cb,
+                                             NULL);
+  addrlen = sizeof(un);
+  memset (&un, 0, sizeof(un));
+  ret = GNUNET_NETWORK_socket_recvfrom (unix_sock,
+                                        buf,
+                                        sizeof(buf),
+                                        (struct sockaddr *) &un,
+                                        &addrlen);
+  if ((-1 == ret) && ((EAGAIN == errno) || (ENOBUFS == errno)))
+    return;
+  if (-1 == ret)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "recvfrom");
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Read %d bytes from socket %s\n",
+              (int) ret,
+              un.sun_path);
+  GNUNET_assert (AF_UNIX == (un.sun_family));
+  msg = (struct UNIXMessage *) buf;
+  msize = ntohs (msg->header.size);
+  if ((msize < sizeof(struct UNIXMessage)) || (msize > ret))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Wrong message size: %d bytes\n",
+                msize);
+    GNUNET_break_op (0);
+    return;
+  }
+  queue = lookup_queue (&msg->sender, &un, addrlen);
+  if (NULL == queue)
+    queue =
+      setup_queue (&msg->sender, GNUNET_TRANSPORT_CS_INBOUND, &un, addrlen);
+  else
+    reschedule_queue_timeout (queue);
+  if (NULL == queue)
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_ERROR,
+      _ (
+        "Maximum number of UNIX connections exceeded, dropping incoming message\n"));
+    return;
+  }
+
+  {
+    uint16_t tsize = msize - sizeof(struct UNIXMessage);
+
+    const struct GNUNET_MessageHeader *currhdr;
+    struct GNUNET_MessageHeader al_hdr;
+
+    currhdr = (const struct GNUNET_MessageHeader *) &msg[1];
+    /* ensure aligned access */
+    memcpy (&al_hdr, currhdr, sizeof(al_hdr));
+    if ((tsize < sizeof(struct GNUNET_MessageHeader)) ||
+        (tsize != ntohs (al_hdr.size)))
+    {
+      GNUNET_break_op (0);
+      return;
+    }
+    ret = GNUNET_TRANSPORT_communicator_receive (ch,
+                                                 &msg->sender,
+                                                 currhdr,
+                                                 GNUNET_TIME_UNIT_FOREVER_REL,
+                                                 &receive_complete_cb,
+                                                 NULL);
+    if (GNUNET_SYSERR == ret)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Transport not up!\n");
+      return;   /* transport not up */
+    }
+    if (GNUNET_NO == ret)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Error sending message to transport\n");
+      return;
+    }
+    delivering_messages++;
+  }
+  if (delivering_messages >= max_queue_length)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Back pressure %llu\n", delivering_messages);
+
+    /* we should try to apply 'back pressure' */
+    GNUNET_SCHEDULER_cancel (read_task);
+    read_task = NULL;
+  }
+}
+
+
+/**
+ * Function called by the transport service to initialize a
+ * message queue given address information about another peer.
+ * If and when the communication channel is established, the
+ * communicator must call #GNUNET_TRANSPORT_communicator_mq_add()
+ * to notify the service that the channel is now up.  It is
+ * the responsibility of the communicator to manage sane
+ * retries and timeouts for any @a peer/@a address combination
+ * provided by the transport service.  Timeouts and retries
+ * do not need to be signalled to the transport service.
+ *
+ * @param cls closure
+ * @param peer identity of the other peer
+ * @param address where to send the message, human-readable
+ *        communicator-specific format, 0-terminated, UTF-8
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if the provided address is invalid
+ */
+static int
+mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
+{
+  struct Queue *queue;
+  const char *path;
+  struct sockaddr_un *un;
+  socklen_t un_len;
+
+  (void) cls;
+  if (0 != strncmp (address,
+                    COMMUNICATOR_ADDRESS_PREFIX "-",
+                    strlen (COMMUNICATOR_ADDRESS_PREFIX "-")))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  path = &address[strlen (COMMUNICATOR_ADDRESS_PREFIX "-")];
+  un = unix_address_to_sockaddr (path, &un_len);
+  queue = lookup_queue (peer, un, un_len);
+  if (NULL != queue)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Address `%s' for %s ignored, queue exists\n",
+                path,
+                GNUNET_i2s (peer));
+    GNUNET_free (un);
+    return GNUNET_OK;
+  }
+  queue = setup_queue (peer, GNUNET_TRANSPORT_CS_OUTBOUND, un, un_len);
+  GNUNET_free (un);
+  if (NULL == queue)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Failed to setup queue to %s at `%s'\n",
+                GNUNET_i2s (peer),
+                path);
+    return GNUNET_NO;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Iterator over all message queues to clean up.
+ *
+ * @param cls NULL
+ * @param target unused
+ * @param value the queue to destroy
+ * @return #GNUNET_OK to continue to iterate
+ */
+static int
+get_queue_delete_it (void *cls,
+                     const struct GNUNET_PeerIdentity *target,
+                     void *value)
+{
+  struct Queue *queue = value;
+
+  (void) cls;
+  (void) target;
+  queue_destroy (queue);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Shutdown the UNIX communicator.
+ *
+ * @param cls NULL (always)
+ */
+static void
+do_shutdown (void *cls)
+{
+  if (NULL != read_task)
+  {
+    GNUNET_SCHEDULER_cancel (read_task);
+    read_task = NULL;
+  }
+  if (NULL != write_task)
+  {
+    GNUNET_SCHEDULER_cancel (write_task);
+    write_task = NULL;
+  }
+  if (NULL != unix_sock)
+  {
+    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (unix_sock));
+    unix_sock = NULL;
+  }
+  GNUNET_CONTAINER_multipeermap_iterate (queue_map, &get_queue_delete_it, NULL);
+  GNUNET_CONTAINER_multipeermap_destroy (queue_map);
+  if (NULL != ai)
+  {
+    GNUNET_TRANSPORT_communicator_address_remove (ai);
+    ai = NULL;
+  }
+  if (NULL != ch)
+  {
+    GNUNET_TRANSPORT_communicator_disconnect (ch);
+    ch = NULL;
+  }
+  if (NULL != stats)
+  {
+    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
+    stats = NULL;
+  }
+}
+
+
+/**
+ * Function called when the transport service has received an
+ * acknowledgement for this communicator (!) via a different return
+ * path.
+ *
+ * Not applicable for UNIX.
+ *
+ * @param cls closure
+ * @param sender which peer sent the notification
+ * @param msg payload
+ */
+static void
+enc_notify_cb (void *cls,
+               const struct GNUNET_PeerIdentity *sender,
+               const struct GNUNET_MessageHeader *msg)
+{
+  (void) cls;
+  (void) sender;
+  (void) msg;
+  GNUNET_break_op (0);
+}
+
+
+/**
+ * Setup communicator and launch network interactions.
+ *
+ * @param cls NULL (always)
+ * @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 *unix_socket_path;
+  struct sockaddr_un *un;
+  socklen_t un_len;
+  char *my_addr;
+  struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
+
+  (void) cls;
+  delivering_messages = 0;
+
+  my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
+  if (NULL == my_private_key)
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_ERROR,
+      _ (
+        "UNIX communicator is lacking key configuration settings. Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key);
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                               COMMUNICATOR_CONFIG_SECTION,
+                                               "UNIXPATH",
+                                               &unix_socket_path))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               COMMUNICATOR_CONFIG_SECTION,
+                               "UNIXPATH");
+    return;
+  }
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_number (cfg,
+                                             COMMUNICATOR_CONFIG_SECTION,
+                                             "MAX_QUEUE_LENGTH",
+                                             &max_queue_length))
+    max_queue_length = DEFAULT_MAX_QUEUE_LENGTH;
+
+  un = unix_address_to_sockaddr (unix_socket_path, &un_len);
+  if (NULL == un)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to setup UNIX domain socket address with path `%s'\n",
+                unix_socket_path);
+    GNUNET_free (unix_socket_path);
+    return;
+  }
+  unix_sock = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_DGRAM, 0);
+  if (NULL == unix_sock)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
+    GNUNET_free (un);
+    GNUNET_free (unix_socket_path);
+    return;
+  }
+  if (('\0' != un->sun_path[0]) &&
+      (GNUNET_OK != GNUNET_DISK_directory_create_for_file (un->sun_path)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Cannot create path to `%s'\n"),
+                un->sun_path);
+    GNUNET_NETWORK_socket_close (unix_sock);
+    unix_sock = NULL;
+    GNUNET_free (un);
+    GNUNET_free (unix_socket_path);
+    return;
+  }
+  if (GNUNET_OK != GNUNET_NETWORK_socket_bind (unix_sock,
+                                               (const struct sockaddr *) un,
+                                               un_len))
+  {
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "bind", un->sun_path);
+    GNUNET_NETWORK_socket_close (unix_sock);
+    unix_sock = NULL;
+    GNUNET_free (un);
+    GNUNET_free (unix_socket_path);
+    return;
+  }
+  GNUNET_free (un);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Bound to `%s'\n", unix_socket_path);
+  stats = GNUNET_STATISTICS_create ("C-UNIX", cfg);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
+  read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                             unix_sock,
+                                             &select_read_cb,
+                                             NULL);
+  queue_map = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
+  ch = GNUNET_TRANSPORT_communicator_connect (cfg,
+                                              COMMUNICATOR_CONFIG_SECTION,
+                                              COMMUNICATOR_ADDRESS_PREFIX,
+                                              GNUNET_TRANSPORT_CC_RELIABLE,
+                                              &mq_init,
+                                              NULL,
+                                              &enc_notify_cb,
+                                              NULL);
+  if (NULL == ch)
+  {
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    GNUNET_free (unix_socket_path);
+    return;
+  }
+  GNUNET_asprintf (&my_addr,
+                   "%s-%s",
+                   COMMUNICATOR_ADDRESS_PREFIX,
+                   unix_socket_path);
+  GNUNET_free (unix_socket_path);
+  ai = GNUNET_TRANSPORT_communicator_address_add (ch,
+                                                  my_addr,
+                                                  GNUNET_NT_LOOPBACK,
+                                                  GNUNET_TIME_UNIT_FOREVER_REL);
+  GNUNET_free (my_addr);
+}
+
+
+/**
+ * The main function for the UNIX communicator.
+ *
+ * @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
+  };
+  int ret;
+
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
+    return 2;
+
+  ret = (GNUNET_OK ==
+         GNUNET_PROGRAM_run (argc,
+                             argv,
+                             "gnunet-communicator-unix",
+                             _ ("GNUnet UNIX domain socket communicator"),
+                             options,
+                             &run,
+                             NULL))
+        ? 0
+        : 1;
+  GNUNET_free_nz ((void *) argv);
+  return ret;
+}
+
+
+#if defined(__linux__) && defined(__GLIBC__)
+#include <malloc.h>
+
+/**
+ * MINIMIZE heap size (way below 128k) since this process doesn't need much.
+ */
+void __attribute__ ((constructor))
+GNUNET_TRANSPORT_communicator_unix_memory_init ()
+{
+  mallopt (M_TRIM_THRESHOLD, 4 * 1024);
+  mallopt (M_TOP_PAD, 1 * 1024);
+  malloc_trim (0);
+}
+
+
+#endif
+
+/* end of gnunet-communicator-unix.c */
diff --git a/src/service/transport/gnunet-service-transport.c b/src/service/transport/gnunet-service-transport.c
new file mode 100644
index 000000000..91ce801db
--- /dev/null
+++ b/src/service/transport/gnunet-service-transport.c
@@ -0,0 +1,12663 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2010-2016, 2018, 2019 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 transport/gnunet-service-transport.c
+ * @brief main for gnunet-service-transport
+ * @author Christian Grothoff
+ *
+ * TODO:
+ * Implement next:
+ * - review retransmission logic, right now there is no smartness there!
+ *   => congestion control, etc [PERFORMANCE-BASICS]
+ *
+ * Optimizations-Statistics:
+ * - Track ACK losses based on ACK-counter [ROUTING]
+ * - Need to track total bandwidth per VirtualLink and adjust how frequently
+ *   we send FC messages based on bandwidth-delay-product (and relation
+ *   to the window size!). See OPTIMIZE-FC-BDP.
+ * - Consider more statistics in #check_connection_quality() [FIXME-CONQ-STATISTICS]
+ * - Adapt available_fc_window_size, using larger values for high-bandwidth
+ *   and high-latency links *if* we have the RAM [GOODPUT / utilization / stalls]
+ * - Set last_window_consum_limit promise properly based on
+ *   latency and bandwidth of the respective connection [GOODPUT / utilization / stalls]
+ *
+ * Optimizations-DV:
+ * - When forwarding DV learn messages, if a peer is reached that
+ *   has a *bidirectional* link to the origin beyond 1st hop,
+ *   do NOT forward it to peers _other_ than the origin, as
+ *   there is clearly a better path directly from the origin to
+ *   whatever else we could reach.
+ * - When we passively learned DV (with unconfirmed freshness), we
+ *   right now add the path to our list but with a zero path_valid_until
+ *   time and only use it for unconfirmed routes.  However, we could consider
+ *   triggering an explicit validation mechanism ourselves, specifically routing
+ *   a challenge-response message over the path [ROUTING]
+ * = if available, try to confirm unconfirmed DV paths when trying to establish
+ *   virtual link for a `struct IncomingRequest`. (i.e. if DVH is
+ *   unconfirmed, incoming requests cause us to try to validate a passively
+ *   learned path (requires new message type!))
+ *
+ * Optimizations-Fragmentation:
+ * - Fragments send over a reliable channel could do without the
+ *   AcknowledgementUUIDP altogether, as they won't be acked! [BANDWIDTH]
+ *   (-> have 2nd type of acknowledgment message; low priority, as we
+ *       do not have an MTU-limited *reliable* communicator) [FIXME-FRAG-REL-UUID]
+ * - if messages are below MTU, consider adding ACKs and other stuff
+ *   to the same transmission to avoid tiny messages (requires planning at
+ *   receiver, and additional MST-style demultiplex at receiver!) [PACKET COUNT]
+ *
+ * Optimizations-internals:
+ * - queue_send_msg by API design has to make a copy
+ *   of the payload, and route_message on top of that requires a malloc/free.
+ *   Change design to approximate "zero" copy better... [CPU]
+ * - could avoid copying body of message into each fragment and keep
+ *   fragments as just pointers into the original message and only
+ *   fully build fragments just before transmission (optimization, should
+ *   reduce CPU and memory use) [CPU, MEMORY]
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_statistics_service.h"
+#include "gnunet_transport_monitor_service.h"
+#include "gnunet_peerstore_service.h"
+#include "gnunet_nat_service.h"
+#include "gnunet_hello_uri_lib.h"
+#include "gnunet_signatures.h"
+#include "transport.h"
+
+/**
+ * Size of ring buffer to cache CORE and forwarded DVBox messages.
+ */
+#define RING_BUFFER_SIZE 16
+
+/**
+ * Maximum number of FC retransmissions for a running retransmission task.
+ */
+#define MAX_FC_RETRANSMIT_COUNT 1000
+
+/**
+ * Maximum number of messages we acknowledge together in one
+ * cumulative ACK.  Larger values may save a bit of bandwidth.
+ */
+#define MAX_CUMMULATIVE_ACKS 64
+
+/**
+ * What is the 1:n chance that we send a Flow control response when
+ * receiving a flow control message that did not change anything for
+ * us? Basically, this is used in the case where both peers are stuck
+ * on flow control (no window changes), but one might continue sending
+ * flow control messages to the other peer as the first FC message
+ * when things stalled got lost, and then subsequently the other peer
+ * does *usually* not respond as nothing changed.  So to ensure that
+ * eventually the FC messages stop, we do send with 1/8th probability
+ * an FC message even if nothing changed.  That prevents one peer
+ * being stuck in sending (useless) FC messages "forever".
+ */
+#define FC_NO_CHANGE_REPLY_PROBABILITY 8
+
+/**
+ * What is the size we assume for a read operation in the
+ * absence of an MTU for the purpose of flow control?
+ */
+#define IN_PACKET_SIZE_WITHOUT_MTU 128
+
+/**
+ * Number of slots we keep of historic data for computation of
+ * goodput / message loss ratio.
+ */
+#define GOODPUT_AGING_SLOTS 4
+
+/**
+ * How big is the flow control window size by default;
+ * limits per-neighbour RAM utilization.
+ */
+#define DEFAULT_WINDOW_SIZE (128 * 1024)
+
+/**
+ * For how many incoming connections do we try to create a
+ * virtual link for (at the same time!).  This does NOT
+ * limit the number of incoming connections, just the number
+ * for which we are actively trying to find working addresses
+ * in the absence (!) of our own applications wanting the
+ * link to go up.
+ */
+#define MAX_INCOMING_REQUEST 16
+
+/**
+ * Maximum number of peers we select for forwarding DVInit
+ * messages at the same time (excluding initiator).
+ */
+#define MAX_DV_DISCOVERY_SELECTION 16
+
+/**
+ * Window size. How many messages to the same target do we pass
+ * to CORE without a RECV_OK in between? Small values limit
+ * thoughput, large values will increase latency.
+ *
+ * FIXME-OPTIMIZE: find out what good values are experimentally,
+ * maybe set adaptively (i.e. to observed available bandwidth).
+ */
+#define RECV_WINDOW_SIZE 4
+
+/**
+ * Minimum number of hops we should forward DV learn messages
+ * even if they are NOT useful for us in hope of looping
+ * back to the initiator?
+ *
+ * FIXME: allow initiator some control here instead?
+ */
+#define MIN_DV_PATH_LENGTH_FOR_INITIATOR 3
+
+/**
+ * Maximum DV distance allowed ever.
+ */
+#define MAX_DV_HOPS_ALLOWED 16
+
+/**
+ * Maximum number of DV learning activities we may
+ * have pending at the same time.
+ */
+#define MAX_DV_LEARN_PENDING 64
+
+/**
+ * Maximum number of DV paths we keep simultaneously to the same target.
+ */
+#define MAX_DV_PATHS_TO_TARGET 3
+
+/**
+ * If a queue delays the next message by more than this number
+ * of seconds we log a warning. Note: this is for testing,
+ * the value chosen here might be too aggressively low!
+ */
+#define DELAY_WARN_THRESHOLD \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
+
+/**
+ * If a DVBox could not be forwarded after this number of
+ * seconds we drop it.
+ */
+#define DV_FORWARD_TIMEOUT \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
+
+/**
+ * Default value for how long we wait for reliability ack.
+ */
+#define DEFAULT_ACK_WAIT_DURATION \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
+
+/**
+ * We only consider queues as "quality" connections when
+ * suppressing the generation of DV initiation messages if
+ * the latency of the queue is below this threshold.
+ */
+#define DV_QUALITY_RTT_THRESHOLD \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
+
+/**
+ * How long do we consider a DV path valid if we see no
+ * further updates on it? Note: the value chosen here might be too low!
+ */
+#define DV_PATH_VALIDITY_TIMEOUT \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
+
+/**
+ * How long do we cache backchannel (struct Backtalker) information
+ * after a backchannel goes inactive?
+ */
+#define BACKCHANNEL_INACTIVITY_TIMEOUT \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
+
+/**
+ * How long before paths expire would we like to (re)discover DV paths? Should
+ * be below #DV_PATH_VALIDITY_TIMEOUT.
+ */
+#define DV_PATH_DISCOVERY_FREQUENCY \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 4)
+
+/**
+ * How long are ephemeral keys valid?
+ */
+#define EPHEMERAL_VALIDITY \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
+
+/**
+ * How long do we keep partially reassembled messages around before giving up?
+ */
+#define REASSEMBLY_EXPIRATION \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 4)
+
+/**
+ * What is the fastest rate at which we send challenges *if* we keep learning
+ * an address (gossip, DHT, etc.)?
+ */
+#define FAST_VALIDATION_CHALLENGE_FREQ \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 1)
+
+/**
+ * What is the slowest rate at which we send challenges?
+ */
+#define MAX_VALIDATION_CHALLENGE_FREQ \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_DAYS, 1)
+
+/**
+ * How long until we forget about historic accumulators and thus
+ * reset the ACK counter? Should exceed the maximum time an
+ * active connection experiences without an ACK.
+ */
+#define ACK_CUMMULATOR_TIMEOUT \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
+
+/**
+ * What is the non-randomized base frequency at which we
+ * would initiate DV learn messages?
+ */
+#define DV_LEARN_BASE_FREQUENCY GNUNET_TIME_UNIT_MINUTES
+
+/**
+ * How many good connections (confirmed, bi-directional, not DV)
+ * do we need to have to suppress initiating DV learn messages?
+ */
+#define DV_LEARN_QUALITY_THRESHOLD 100
+
+/**
+ * When do we forget an invalid address for sure?
+ */
+#define MAX_ADDRESS_VALID_UNTIL \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MONTHS, 1)
+
+/**
+ * How long do we consider an address valid if we just checked?
+ */
+#define ADDRESS_VALIDATION_LIFETIME \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
+
+/**
+ * What is the maximum frequency at which we do address validation?
+ * A random value between 0 and this value is added when scheduling
+ * the #validation_task (both to ensure we do not validate too often,
+ * and to randomize a bit).
+ */
+#define MIN_DELAY_ADDRESS_VALIDATION GNUNET_TIME_UNIT_MILLISECONDS
+
+/**
+ * How many network RTTs before an address validation expires should we begin
+ * trying to revalidate? (Note that the RTT used here is the one that we
+ * experienced during the last validation, not necessarily the latest RTT
+ * observed).
+ */
+#define VALIDATION_RTT_BUFFER_FACTOR 3
+
+/**
+ * How many messages can we have pending for a given communicator
+ * process before we start to throttle that communicator?
+ *
+ * Used if a communicator might be CPU-bound and cannot handle the traffic.
+ */
+#define COMMUNICATOR_TOTAL_QUEUE_LIMIT 512
+
+/**
+ * How many messages can we have pending for a given queue (queue to
+ * a particular peer via a communicator) process before we start to
+ * throttle that queue?
+ */
+#define QUEUE_LENGTH_LIMIT 32
+
+/**
+ *
+ */
+#define QUEUE_ENTRY_TIMEOUT \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
+
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * Unique identifier we attach to a message.
+ */
+struct MessageUUIDP
+{
+  /**
+   * Unique value, generated by incrementing the
+   * `message_uuid_ctr` of `struct Neighbour`.
+   */
+  uint64_t uuid GNUNET_PACKED;
+};
+
+
+/**
+ * Unique identifier to map an acknowledgement to a transmission.
+ */
+struct AcknowledgementUUIDP
+{
+  /**
+   * The UUID value.
+   */
+  struct GNUNET_Uuid value;
+};
+
+/**
+ * Outer layer of an encapsulated backchannel message.
+ */
+struct TransportBackchannelEncapsulationMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /* Followed by *another* message header which is the message to
+     the communicator */
+
+  /* Followed by a 0-terminated name of the communicator */
+};
+
+
+/**
+ * Body by which a peer confirms that it is using an ephemeral key.
+ */
+struct EphemeralConfirmationPS
+{
+  /**
+   * Purpose is #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+
+  /**
+   * How long is this signature over the ephemeral key valid?
+   *
+   * Note that the receiver MUST IGNORE the absolute time, and only interpret
+   * the value as a mononic time and reject "older" values than the last one
+   * observed.  This is necessary as we do not want to require synchronized
+   * clocks and may not have a bidirectional communication channel.
+   *
+   * Even with this, there is no real guarantee against replay achieved here,
+   * unless the latest timestamp is persisted.  While persistence should be
+   * provided via PEERSTORE, we do not consider the mechanism reliable!  Thus,
+   * communicators must protect against replay attacks when using backchannel
+   * communication!
+   */
+  struct GNUNET_TIME_AbsoluteNBO sender_monotonic_time;
+
+  /**
+   * Target's peer identity.
+   */
+  struct GNUNET_PeerIdentity target;
+
+  /**
+   * Ephemeral key setup by the sender for @e target, used
+   * to encrypt the payload.
+   */
+  struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key;
+};
+
+
+/**
+ * Plaintext of the variable-size payload that is encrypted
+ * within a `struct TransportBackchannelEncapsulationMessage`
+ */
+struct TransportDVBoxPayloadP
+{
+  /**
+   * Sender's peer identity.
+   */
+  struct GNUNET_PeerIdentity sender;
+
+  /**
+   * Signature of the sender over an
+   * #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL.
+   */
+  struct GNUNET_CRYPTO_EddsaSignature sender_sig;
+
+  /**
+   * Current monotonic time of the sending transport service.  Used to
+   * detect replayed messages.  Note that the receiver should remember
+   * a list of the recently seen timestamps and only reject messages
+   * if the timestamp is in the list, or the list is "full" and the
+   * timestamp is smaller than the lowest in the list.
+   *
+   * Like the @e ephemeral_validity, the list of timestamps per peer should be
+   * persisted to guard against replays after restarts.
+   */
+  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
+
+  /* Followed by a `struct GNUNET_MessageHeader` with a message
+     for the target peer */
+};
+
+
+/**
+ * Outer layer of an encapsulated unfragmented application message sent
+ * over an unreliable channel.
+ */
+struct TransportReliabilityBoxMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Number of messages still to be sent before a commulative
+   * ACK is requested.  Zero if an ACK is requested immediately.
+   * In NBO.  Note that the receiver may send the ACK faster
+   * if it believes that is reasonable.
+   */
+  uint32_t ack_countdown GNUNET_PACKED;
+
+  /**
+   * Unique ID of the message used for signalling receipt of
+   * messages sent over possibly unreliable channels.  Should
+   * be a random.
+   */
+  struct AcknowledgementUUIDP ack_uuid;
+};
+
+
+/**
+ * Acknowledgement payload.
+ */
+struct TransportCummulativeAckPayloadP
+{
+  /**
+   * How long was the ACK delayed for generating cumulative ACKs?
+   * Used to calculate the correct network RTT by taking the receipt
+   * time of the ack minus the transmission time of the sender minus
+   * this value.
+   */
+  struct GNUNET_TIME_RelativeNBO ack_delay;
+
+  /**
+   * UUID of a message being acknowledged.
+   */
+  struct AcknowledgementUUIDP ack_uuid;
+};
+
+
+/**
+ * Confirmation that the receiver got a
+ * #GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX. Note that the
+ * confirmation may be transmitted over a completely different queue,
+ * so ACKs are identified by a combination of PID of sender and
+ * message UUID, without the queue playing any role!
+ */
+struct TransportReliabilityAckMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Counter of ACKs transmitted by the sender to us. Incremented
+   * by one for each ACK, used to detect how many ACKs were lost.
+   */
+  uint32_t ack_counter GNUNET_PACKED;
+
+  /* followed by any number of `struct TransportCummulativeAckPayloadP`
+     messages providing ACKs */
+};
+
+
+/**
+ * Outer layer of an encapsulated fragmented application message.
+ */
+struct TransportFragmentBoxMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Offset of this fragment in the overall message.
+   */
+  uint16_t frag_off GNUNET_PACKED;
+
+  /**
+   * Total size of the message that is being fragmented.
+   */
+  uint16_t msg_size GNUNET_PACKED;
+
+  /**
+   * Unique ID of this fragment (and fragment transmission!). Will
+   * change even if a fragment is retransmitted to make each
+   * transmission attempt unique! If a client receives a duplicate
+   * fragment (same @e frag_off for same @a msg_uuid, it must send
+   * #GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK immediately.
+   */
+  struct AcknowledgementUUIDP ack_uuid;
+
+  /**
+   * Original message ID for of the message that all the fragments
+   * belong to.  Must be the same for all fragments.
+   */
+  struct MessageUUIDP msg_uuid;
+};
+
+
+/**
+ * Content signed by the initator during DV learning.
+ *
+ * The signature is required to prevent DDoS attacks. A peer sending out this
+ * message is potentially generating a lot of traffic that will go back to the
+ * initator, as peers receiving this message will try to let the initiator
+ * know that they got the message.
+ *
+ * Without this signature, an attacker could abuse this mechanism for traffic
+ * amplification, sending a lot of traffic to a peer by putting out this type
+ * of message with the victim's peer identity.
+ *
+ * Even with just a signature, traffic amplification would be possible via
+ * replay attacks. The @e monotonic_time limits such replay attacks, as every
+ * potential amplificator will check the @e monotonic_time and only respond
+ * (at most) once per message.
+ */
+struct DvInitPS
+{
+  /**
+   * Purpose is #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+
+  /**
+   * Time at the initiator when generating the signature.
+   *
+   * Note that the receiver MUST IGNORE the absolute time, and only interpret
+   * the value as a mononic time and reject "older" values than the last one
+   * observed.  This is necessary as we do not want to require synchronized
+   * clocks and may not have a bidirectional communication channel.
+   *
+   * Even with this, there is no real guarantee against replay achieved here,
+   * unless the latest timestamp is persisted.  Persistence should be
+   * provided via PEERSTORE if possible.
+   */
+  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
+
+  /**
+   * Challenge value used by the initiator to re-identify the path.
+   */
+  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
+};
+
+
+/**
+ * Content signed by each peer during DV learning.
+ *
+ * This assues the initiator of the DV learning operation that the hop from @e
+ * pred via the signing peer to @e succ actually exists.  This makes it
+ * impossible for an adversary to supply the network with bogus routes.
+ *
+ * The @e challenge is included to provide replay protection for the
+ * initiator. This way, the initiator knows that the hop existed after the
+ * original @e challenge was first transmitted, providing a freshness metric.
+ *
+ * Peers other than the initiator that passively learn paths by observing
+ * these messages do NOT benefit from this. Here, an adversary may indeed
+ * replay old messages.  Thus, passively learned paths should always be
+ * immediately marked as "potentially stale".
+ */
+struct DvHopPS
+{
+  /**
+   * Purpose is #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+
+  /**
+   * Identity of the previous peer on the path.
+   */
+  struct GNUNET_PeerIdentity pred;
+
+  /**
+   * Identity of the next peer on the path.
+   */
+  struct GNUNET_PeerIdentity succ;
+
+  /**
+   * Challenge value used by the initiator to re-identify the path.
+   */
+  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
+};
+
+
+/**
+ * An entry describing a peer on a path in a
+ * `struct TransportDVLearnMessage` message.
+ */
+struct DVPathEntryP
+{
+  /**
+   * Identity of a peer on the path.
+   */
+  struct GNUNET_PeerIdentity hop;
+
+  /**
+   * Signature of this hop over the path, of purpose
+   * #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP
+   */
+  struct GNUNET_CRYPTO_EddsaSignature hop_sig;
+};
+
+
+/**
+ * Internal message used by transport for distance vector learning.
+ * If @e num_hops does not exceed the threshold, peers should append
+ * themselves to the peer list and flood the message (possibly only
+ * to a subset of their neighbours to limit discoverability of the
+ * network topology).  To the extend that the @e bidirectional bits
+ * are set, peers may learn the inverse paths even if they did not
+ * initiate.
+ *
+ * Unless received on a bidirectional queue and @e num_hops just
+ * zero, peers that can forward to the initator should always try to
+ * forward to the initiator.
+ */
+struct TransportDVLearnMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Number of hops this messages has travelled, in NBO. Zero if
+   * sent by initiator.
+   */
+  uint16_t num_hops GNUNET_PACKED;
+
+  /**
+   * Bitmask of the last 16 hops indicating whether they are confirmed
+   * available (without DV) in both directions or not, in NBO.  Used
+   * to possibly instantly learn a path in both directions.  Each peer
+   * should shift this value by one to the left, and then set the
+   * lowest bit IF the current sender can be reached from it (without
+   * DV routing).
+   */
+  uint16_t bidirectional GNUNET_PACKED;
+
+  /**
+   * Peers receiving this message and delaying forwarding to other
+   * peers for any reason should increment this value by the non-network
+   * delay created by the peer.
+   */
+  struct GNUNET_TIME_RelativeNBO non_network_delay;
+
+  /**
+   * Time at the initiator when generating the signature.
+   *
+   * Note that the receiver MUST IGNORE the absolute time, and only interpret
+   * the value as a mononic time and reject "older" values than the last one
+   * observed.  This is necessary as we do not want to require synchronized
+   * clocks and may not have a bidirectional communication channel.
+   *
+   * Even with this, there is no real guarantee against replay achieved here,
+   * unless the latest timestamp is persisted.  Persistence should be
+   * provided via PEERSTORE if possible.
+   */
+  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
+
+  /**
+   * Signature of this hop over the path, of purpose
+   * #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR
+   */
+  struct GNUNET_CRYPTO_EddsaSignature init_sig;
+
+  /**
+   * Identity of the peer that started this learning activity.
+   */
+  struct GNUNET_PeerIdentity initiator;
+
+  /**
+   * Challenge value used by the initiator to re-identify the path.
+   */
+  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
+
+  /* Followed by @e num_hops `struct DVPathEntryP` values,
+     excluding the initiator of the DV trace; the last entry is the
+     current sender; the current peer must not be included. */
+};
+
+
+/**
+ * Outer layer of an encapsulated message send over multiple hops.
+ * The path given only includes the identities of the subsequent
+ * peers, i.e. it will be empty if we are the receiver. Each
+ * forwarding peer should scan the list from the end, and if it can,
+ * forward to the respective peer. The list should then be shortened
+ * by all the entries up to and including that peer.  Each hop should
+ * also increment @e total_hops to allow the receiver to get a precise
+ * estimate on the number of hops the message travelled.  Senders must
+ * provide a learned path that thus should work, but intermediaries
+ * know of a shortcut, they are allowed to send the message via that
+ * shortcut.
+ *
+ * If a peer finds itself still on the list, it must drop the message.
+ *
+ * The payload of the box can only be decrypted and verified by the
+ * ultimate receiver. Intermediaries do not learn the sender's
+ * identity and the path the message has taken.  However, the first
+ * hop does learn the sender as @e total_hops would be zero and thus
+ * the predecessor must be the origin (so this is not really useful
+ * for anonymization).
+ */
+struct TransportDVBoxMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Flag if the payload is a control message. In NBO.
+   */
+  unsigned int without_fc;
+
+  /**
+   * Number of total hops this messages travelled. In NBO.
+   * @e origin sets this to zero, to be incremented at
+   * each hop.  Peers should limit the @e total_hops value
+   * they accept from other peers.
+   */
+  uint16_t total_hops GNUNET_PACKED;
+
+  /**
+   * Number of hops this messages includes. In NBO.  Reduced by one
+   * or more at each hop.  Peers should limit the @e num_hops value
+   * they accept from other peers.
+   */
+  uint16_t num_hops GNUNET_PACKED;
+
+  /**
+   * Ephemeral key setup by the sender for target, used to encrypt the
+   * payload.  Intermediaries must not change this value.
+   */
+  struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key;
+
+  /**
+   * We use an IV here as the @e ephemeral_key is re-used for
+   * #EPHEMERAL_VALIDITY time to avoid re-signing it all the time.
+   * Intermediaries must not change this value.
+   */
+  struct GNUNET_ShortHashCode iv;
+
+  /**
+   * HMAC over the ciphertext of the encrypted, variable-size body
+   * that follows.  Verified via DH of target and @e ephemeral_key.
+   * Intermediaries must not change this value.
+   */
+  struct GNUNET_HashCode hmac;
+
+  /**
+   * Size this msg had initially. This is needed to calculate the hmac at the target.
+   * The header size can not be used for that, because the box size is getting smaller at each hop.
+   *
+   */
+  uint16_t orig_size GNUNET_PACKED;
+
+  /* Followed by @e num_hops `struct GNUNET_PeerIdentity` values;
+     excluding the @e origin and the current peer, the last must be
+     the ultimate target; if @e num_hops is zero, the receiver of this
+     message is the ultimate target. */
+
+  /* Followed by encrypted, variable-size payload, which
+     must begin with a `struct TransportDVBoxPayloadP` */
+
+  /* Followed by the actual message, which itself must not be a
+     a DV_LEARN or DV_BOX message! */
+};
+
+
+/**
+ * Message send to another peer to validate that it can indeed
+ * receive messages at a particular address.
+ */
+struct TransportValidationChallengeMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Always zero.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * Challenge to be signed by the receiving peer.
+   */
+  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
+
+  /**
+   * Timestamp of the sender, to be copied into the reply to allow
+   * sender to calculate RTT.  Must be monotonically increasing!
+   */
+  struct GNUNET_TIME_AbsoluteNBO sender_time;
+};
+
+
+/**
+ * Message signed by a peer to confirm that it can indeed
+ * receive messages at a particular address.
+ */
+struct TransportValidationPS
+{
+  /**
+   * Purpose is #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+
+  /**
+   * How long does the sender believe the address on
+   * which the challenge was received to remain valid?
+   */
+  struct GNUNET_TIME_RelativeNBO validity_duration;
+
+  /**
+   * Challenge signed by the receiving peer.
+   */
+  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
+};
+
+
+/**
+ * Message  send to a peer to respond to a
+ * #GNUNET_MESSAGE_TYPE_ADDRESS_VALIDATION_CHALLENGE
+ */
+struct TransportValidationResponseMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Always zero.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * The peer's signature matching the
+   * #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE purpose.
+   */
+  struct GNUNET_CRYPTO_EddsaSignature signature;
+
+  /**
+   * The challenge that was signed by the receiving peer.
+   */
+  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
+
+  /**
+   * Original timestamp of the sender (was @code{sender_time}),
+   * copied into the reply to allow sender to calculate RTT.
+   */
+  struct GNUNET_TIME_AbsoluteNBO origin_time;
+
+  /**
+   * How long does the sender believe this address to remain
+   * valid?
+   */
+  struct GNUNET_TIME_RelativeNBO validity_duration;
+};
+
+struct TransportGlobalNattedAddress
+{
+  /**
+   * Length of the address following the struct in NBO.
+   */
+  unsigned int address_length;
+
+  /* Followed by @e address_length bytes of the address. */
+};
+
+/**
+ * Message for Transport-to-Transport Flow control. Specifies the size
+ * of the flow control window, including how much we believe to have
+ * consumed (at transmission time), how much we believe to be allowed
+ * (at transmission time), and how much the other peer is allowed to
+ * send to us, and how much data we already received from the other
+ * peer.
+ */
+struct TransportFlowControlMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Sequence number of the flow control message. Incremented by one
+   * for each message.  Starts at zero when a virtual link goes up.
+   * Used to detect one-sided connection drops. On wrap-around, the
+   * flow control counters will be reset as if the connection had
+   * dropped.
+   */
+  uint32_t seq GNUNET_PACKED;
+
+  /**
+   * Flow control window size in bytes, in NBO.
+   * The receiver can send this many bytes at most.
+   */
+  uint64_t inbound_window_size GNUNET_PACKED;
+
+  /**
+   * How many bytes has the sender sent that count for flow control at
+   * this time.  Used to allow the receiver to estimate the packet
+   * loss rate.
+   */
+  uint64_t outbound_sent GNUNET_PACKED;
+
+  /**
+   * Latest flow control window size we learned from the other peer,
+   * in bytes, in NBO.  We are limited to sending at most this many
+   * bytes to the other peer.  May help the other peer detect when
+   * flow control messages were lost and should thus be retransmitted.
+   * In particular, if the delta to @e outbound_sent is too small,
+   * this signals that we are stalled.
+   */
+  uint64_t outbound_window_size GNUNET_PACKED;
+
+  /**
+   * Timestamp of the sender.  Must be monotonically increasing!
+   * Used to enable receiver to ignore out-of-order packets in
+   * combination with the @e seq. Note that @e seq will go down
+   * (back to zero) whenever either side believes the connection
+   * was dropped, allowing the peers to detect that they need to
+   * reset the counters for the number of bytes sent!
+   */
+  struct GNUNET_TIME_AbsoluteNBO sender_time;
+
+
+  /**
+   * Number of TransportGlobalNattedAddress following the struct.
+   */
+  unsigned int number_of_addresses;
+
+  /**
+   * Size of all the addresses attached to all TransportGlobalNattedAddress.
+   */
+  size_t size_of_addresses;
+
+  /* Followed by @e number_of_addresses struct TransportGlobalNattedAddress. */
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+
+/**
+ * What type of client is the `struct TransportClient` about?
+ */
+enum ClientType
+{
+  /**
+   * We do not know yet (client is fresh).
+   */
+  CT_NONE = 0,
+
+  /**
+   * Is the CORE service, we need to forward traffic to it.
+   */
+  CT_CORE = 1,
+
+  /**
+   * It is a monitor, forward monitor data.
+   */
+  CT_MONITOR = 2,
+
+  /**
+   * It is a communicator, use for communication.
+   */
+  CT_COMMUNICATOR = 3,
+
+  /**
+   * "Application" telling us where to connect (i.e. TOPOLOGY, DHT or CADET).
+   */
+  CT_APPLICATION = 4
+};
+
+
+/**
+ * Which transmission options are allowable for transmission?
+ * Interpreted bit-wise!
+ */
+enum RouteMessageOptions
+{
+  /**
+   * Only confirmed, non-DV direct neighbours.
+   */
+  RMO_NONE = 0,
+
+  /**
+   * We are allowed to use DV routing for this @a hdr
+   */
+  RMO_DV_ALLOWED = 1,
+
+  /**
+   * We are allowed to use unconfirmed queues or DV routes for this message
+   */
+  RMO_UNCONFIRMED_ALLOWED = 2,
+
+  /**
+   * Reliable and unreliable, DV and non-DV are all acceptable.
+   */
+  RMO_ANYTHING_GOES = (RMO_DV_ALLOWED | RMO_UNCONFIRMED_ALLOWED),
+
+  /**
+   * If we have multiple choices, it is OK to send this message
+   * over multiple channels at the same time to improve loss tolerance.
+   * (We do at most 2 transmissions.)
+   */
+  RMO_REDUNDANT = 4
+};
+
+
+/**
+ * When did we launch this DV learning activity?
+ */
+struct LearnLaunchEntry
+{
+  /**
+   * Kept (also) in a DLL sorted by launch time.
+   */
+  struct LearnLaunchEntry *prev;
+
+  /**
+   * Kept (also) in a DLL sorted by launch time.
+   */
+  struct LearnLaunchEntry *next;
+
+  /**
+   * Challenge that uniquely identifies this activity.
+   */
+  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
+
+  /**
+   * When did we transmit the DV learn message (used to calculate RTT) and
+   * determine freshness of paths learned via this operation.
+   */
+  struct GNUNET_TIME_Absolute launch_time;
+};
+
+
+/**
+ * Information we keep per #GOODPUT_AGING_SLOTS about historic
+ * (or current) transmission performance.
+ */
+struct TransmissionHistoryEntry
+{
+  /**
+   * Number of bytes actually sent in the interval.
+   */
+  uint64_t bytes_sent;
+
+  /**
+   * Number of bytes received and acknowledged by the other peer in
+   * the interval.
+   */
+  uint64_t bytes_received;
+};
+
+
+/**
+ * Performance data for a transmission possibility.
+ */
+struct PerformanceData
+{
+  /**
+   * Weighted average for the RTT.
+   */
+  struct GNUNET_TIME_Relative aged_rtt;
+
+  /**
+   * Historic performance data, using a ring buffer of#GOODPUT_AGING_SLOTS
+   * entries.
+   */
+  struct TransmissionHistoryEntry the[GOODPUT_AGING_SLOTS];
+
+  /**
+   * What was the last age when we wrote to @e the? Used to clear
+   * old entries when the age advances.
+   */
+  unsigned int last_age;
+};
+
+
+/**
+ * Client connected to the transport service.
+ */
+struct TransportClient;
+
+/**
+ * A neighbour that at least one communicator is connected to.
+ */
+struct Neighbour;
+
+/**
+ * Entry in our #dv_routes table, representing a (set of) distance
+ * vector routes to a particular peer.
+ */
+struct DistanceVector;
+
+/**
+ * A queue is a message queue provided by a communicator
+ * via which we can reach a particular neighbour.
+ */
+struct Queue;
+
+/**
+ * Message awaiting transmission. See detailed comments below.
+ */
+struct PendingMessage;
+
+/**
+ * One possible hop towards a DV target.
+ */
+struct DistanceVectorHop;
+
+/**
+ * A virtual link is another reachable peer that is known to CORE.  It
+ * can be either a `struct Neighbour` with at least one confirmed
+ * `struct Queue`, or a `struct DistanceVector` with at least one
+ * confirmed `struct DistanceVectorHop`.  With a virtual link we track
+ * data that is per neighbour that is not specific to how the
+ * connectivity is established.
+ */
+struct VirtualLink;
+
+
+/**
+ * Context from #handle_incoming_msg().  Closure for many
+ * message handlers below.
+ */
+struct CommunicatorMessageContext
+{
+  /**
+   * Kept in a DLL of `struct VirtualLink` if waiting for CORE
+   * flow control to unchoke.
+   */
+  struct CommunicatorMessageContext *next;
+
+  /**
+   * Kept in a DLL of `struct VirtualLink` if waiting for CORE
+   * flow control to unchoke.
+   */
+  struct CommunicatorMessageContext *prev;
+
+  /**
+   * Which communicator provided us with the message.
+   */
+  struct TransportClient *tc;
+
+  /**
+   * Additional information for flow control and about the sender.
+   */
+  struct GNUNET_TRANSPORT_IncomingMessage im;
+
+  /**
+   * The message to demultiplex.
+   */
+  const struct GNUNET_MessageHeader *mh;
+
+  /**
+   * Number of hops the message has travelled (if DV-routed).
+   * FIXME: make use of this in ACK handling!
+   */
+  uint16_t total_hops;
+
+  /**
+   * Did we already call GNUNET_SERVICE_client_continue and send ACK to communicator?
+   */
+  unsigned int continue_send;
+};
+
+
+/**
+ * Entry for the ring buffer caching messages send to core, when virtual link is avaliable.
+ **/
+struct RingBufferEntry
+{
+  /**
+   * Communicator context for this ring buffer entry.
+   **/
+  struct CommunicatorMessageContext *cmc;
+
+  /**
+   * The message in this entry.
+   **/
+  struct GNUNET_MessageHeader *mh;
+};
+
+
+/**
+ * Closure for #core_env_sent_cb.
+ */
+struct CoreSentContext
+{
+  /**
+   * Kept in a DLL to clear @e vl in case @e vl is lost.
+   */
+  struct CoreSentContext *next;
+
+  /**
+   * Kept in a DLL to clear @e vl in case @e vl is lost.
+   */
+  struct CoreSentContext *prev;
+
+  /**
+   * Virtual link this is about.
+   */
+  struct VirtualLink *vl;
+
+  /**
+   * How big was the message.
+   */
+  uint16_t size;
+
+  /**
+   * By how much should we increment @e vl's
+   * incoming_fc_window_size_used once we are done sending to CORE?
+   * Use to ensure we do not increment twice if there is more than one
+   * CORE client.
+   */
+  uint16_t isize;
+};
+
+
+/**
+ * Information we keep for a message that we are reassembling.
+ */
+struct ReassemblyContext
+{
+  /**
+   * Original message ID for of the message that all the fragments
+   * belong to.
+   */
+  struct MessageUUIDP msg_uuid;
+
+  /**
+   * Which neighbour is this context for?
+   */
+  struct VirtualLink *virtual_link;
+
+  /**
+   * Entry in the reassembly heap (sorted by expiration).
+   */
+  struct GNUNET_CONTAINER_HeapNode *hn;
+
+  /**
+   * Bitfield with @e msg_size bits representing the positions
+   * where we have received fragments.  When we receive a fragment,
+   * we check the bits in @e bitfield before incrementing @e msg_missing.
+   *
+   * Allocated after the reassembled message.
+   */
+  uint8_t *bitfield;
+
+  /**
+   * At what time will we give up reassembly of this message?
+   */
+  struct GNUNET_TIME_Absolute reassembly_timeout;
+
+  /**
+   * Time we received the last fragment.  @e avg_ack_delay must be
+   * incremented by now - @e last_frag multiplied by @e num_acks.
+   */
+  struct GNUNET_TIME_Absolute last_frag;
+
+  /**
+   * How big is the message we are reassembling in total?
+   */
+  uint16_t msg_size;
+
+  /**
+   * How many bytes of the message are still missing?  Defragmentation
+   * is complete when @e msg_missing == 0.
+   */
+  uint16_t msg_missing;
+
+  /* Followed by @e msg_size bytes of the (partially) defragmented original
+   * message */
+
+  /* Followed by @e bitfield data */
+};
+
+
+/**
+ * A virtual link is another reachable peer that is known to CORE.  It
+ * can be either a `struct Neighbour` with at least one confirmed
+ * `struct Queue`, or a `struct DistanceVector` with at least one
+ * confirmed `struct DistanceVectorHop`.  With a virtual link we track
+ * data that is per neighbour that is not specific to how the
+ * connectivity is established.
+ */
+struct VirtualLink
+{
+  /**
+   * Identity of the peer at the other end of the link.
+   */
+  struct GNUNET_PeerIdentity target;
+
+  /**
+   * Map with `struct ReassemblyContext` structs for fragments under
+   * reassembly. May be NULL if we currently have no fragments from
+   * this @e pid (lazy initialization).
+   */
+  struct GNUNET_CONTAINER_MultiHashMap32 *reassembly_map;
+
+  /**
+   * Heap with `struct ReassemblyContext` structs for fragments under
+   * reassembly. May be NULL if we currently have no fragments from
+   * this @e pid (lazy initialization).
+   */
+  struct GNUNET_CONTAINER_Heap *reassembly_heap;
+
+  /**
+   * Task to free old entries from the @e reassembly_heap and @e reassembly_map.
+   */
+  struct GNUNET_SCHEDULER_Task *reassembly_timeout_task;
+
+  /**
+   * Communicators blocked for receiving on @e target as we are waiting
+   * on the @e core_recv_window to increase.
+   */
+  struct CommunicatorMessageContext *cmc_head;
+
+  /**
+   * Communicators blocked for receiving on @e target as we are waiting
+   * on the @e core_recv_window to increase.
+   */
+  struct CommunicatorMessageContext *cmc_tail;
+
+  /**
+   * Head of list of messages pending for this VL.
+   */
+  struct PendingMessage *pending_msg_head;
+
+  /**
+   * Tail of list of messages pending for this VL.
+   */
+  struct PendingMessage *pending_msg_tail;
+
+  /**
+   * Kept in a DLL to clear @e vl in case @e vl is lost.
+   */
+  struct CoreSentContext *csc_tail;
+
+  /**
+   * Kept in a DLL to clear @e vl in case @e vl is lost.
+   */
+  struct CoreSentContext *csc_head;
+
+  /**
+   * Task scheduled to possibly notfiy core that this peer is no
+   * longer counting as confirmed.  Runs the #core_visibility_check(),
+   * which checks that some DV-path or a queue exists that is still
+   * considered confirmed.
+   */
+  struct GNUNET_SCHEDULER_Task *visibility_task;
+
+  /**
+   * Task scheduled to periodically retransmit FC messages (in
+   * case one got lost).
+   */
+  struct GNUNET_SCHEDULER_Task *fc_retransmit_task;
+
+  /**
+   * Number of FC retransmissions for this running task.
+   */
+  unsigned int fc_retransmit_count;
+
+  /**
+   * Is this VirtualLink confirmed.
+   * A unconfirmed VirtualLink might exist, if we got a FC from that target.
+   */
+  unsigned int confirmed;
+
+  /**
+   * Neighbour used by this virtual link, NULL if @e dv is used.
+   */
+  struct Neighbour *n;
+
+  /**
+   * Distance vector used by this virtual link, NULL if @e n is used.
+   */
+  struct DistanceVector *dv;
+
+  /**
+   * Sender timestamp of @e n_challenge, used to generate out-of-order
+   * challenges (as sender's timestamps must be monotonically
+   * increasing).  FIXME: where do we need this?
+   */
+  struct GNUNET_TIME_Absolute n_challenge_time;
+
+  /**
+   * When did we last send a
+   * #GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL message?
+   * Used to determine whether it is time to re-transmit the message.
+   */
+  struct GNUNET_TIME_Absolute last_fc_transmission;
+
+  /**
+   * Sender timestamp of the last
+   * #GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL message we have
+   * received.  Note that we do not persist this monotonic time as we
+   * do not really have to worry about ancient flow control window
+   * sizes after restarts.
+   */
+  struct GNUNET_TIME_Absolute last_fc_timestamp;
+
+  /**
+   * Expected RTT from the last FC transmission. (Zero if the last
+   * attempt failed, but could theoretically be zero even on success.)
+   */
+  struct GNUNET_TIME_Relative last_fc_rtt;
+
+  /**
+   * Used to generate unique UUIDs for messages that are being
+   * fragmented.
+   */
+  uint64_t message_uuid_ctr;
+
+  /**
+   * Memory allocated for this virtual link.  Expresses how much RAM
+   * we are willing to allocate to this virtual link.  OPTIMIZE-ME:
+   * Can be adapted to dedicate more RAM to links that need it, while
+   * sticking to some overall RAM limit.  For now, set to
+   * #DEFAULT_WINDOW_SIZE.
+   */
+  uint64_t available_fc_window_size;
+
+  /**
+   * Memory actually used to buffer packets on this virtual link.
+   * Expresses how much RAM we are currently using for virtual link.
+   * Note that once CORE is done with a packet, we decrement the value
+   * here.
+   */
+  uint64_t incoming_fc_window_size_ram;
+
+  /**
+   * Last flow control window size we provided to the other peer, in
+   * bytes.  We are allowing the other peer to send this
+   * many bytes.
+   */
+  uint64_t incoming_fc_window_size;
+
+  /**
+   * How much of the window did the other peer successfully use (and
+   * we already passed it on to CORE)? Must be below @e
+   * incoming_fc_window_size.   We should effectively signal the
+   * other peer that the window is this much bigger at the next
+   * opportunity / challenge.
+   */
+  uint64_t incoming_fc_window_size_used;
+
+  /**
+   * What is our current estimate on the message loss rate for the sender?
+   * Based on the difference between how much the sender sent according
+   * to the last #GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL message
+   * (@e outbound_sent field) and how much we actually received at that
+   * time (@e incoming_fc_window_size_used).  This delta is then
+   * added onto the @e incoming_fc_window_size when determining the
+   * @e outbound_window_size we send to the other peer.  Initially zero.
+   * May be negative if we (due to out-of-order delivery) actually received
+   * more than the sender claims to have sent in its last FC message.
+   */
+  int64_t incoming_fc_window_size_loss;
+
+  /**
+   * Our current flow control window size in bytes.  We
+   * are allowed to transmit this many bytes to @a n.
+   */
+  uint64_t outbound_fc_window_size;
+
+  /**
+   * How much of our current flow control window size have we
+   * used (in bytes).  Must be below
+   * @e outbound_fc_window_size.
+   */
+  uint64_t outbound_fc_window_size_used;
+
+  /**
+   * What is the most recent FC window the other peer sent us
+   * in `outbound_window_size`? This is basically the window
+   * size value the other peer has definitively received from
+   * us. If it matches @e incoming_fc_window_size, we should
+   * not send a FC message to increase the FC window. However,
+   * we may still send an FC message to notify the other peer
+   * that we received the other peer's FC message.
+   */
+  uint64_t last_outbound_window_size_received;
+
+  /**
+   * Generator for the sequence numbers of
+   * #GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL messages we send.
+   */
+  uint32_t fc_seq_gen;
+
+  /**
+   * Last sequence number of a
+   * #GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL message we have
+   * received.
+   */
+  uint32_t last_fc_seq;
+
+  /**
+   * How many more messages can we send to CORE before we exhaust
+   * the receive window of CORE for this peer? If this hits zero,
+   * we must tell communicators to stop providing us more messages
+   * for this peer.  In fact, the window can go negative as we
+   * have multiple communicators, so per communicator we can go
+   * down by one into the negative range. Furthermore, we count
+   * delivery per CORE client, so if we had multiple cores, that
+   * might also cause a negative window size here (as one message
+   * would decrement the window by one per CORE client).
+   */
+  int core_recv_window;
+};
+
+
+/**
+ * Data structure kept when we are waiting for an acknowledgement.
+ */
+struct PendingAcknowledgement
+{
+  /**
+   * If @e pm is non-NULL, this is the DLL in which this acknowledgement
+   * is kept in relation to its pending message.
+   */
+  struct PendingAcknowledgement *next_pm;
+
+  /**
+   * If @e pm is non-NULL, this is the DLL in which this acknowledgement
+   * is kept in relation to its pending message.
+   */
+  struct PendingAcknowledgement *prev_pm;
+
+  /**
+   * If @e queue is non-NULL, this is the DLL in which this acknowledgement
+   * is kept in relation to the queue that was used to transmit the
+   * @a pm.
+   */
+  struct PendingAcknowledgement *next_queue;
+
+  /**
+   * If @e queue is non-NULL, this is the DLL in which this acknowledgement
+   * is kept in relation to the queue that was used to transmit the
+   * @a pm.
+   */
+  struct PendingAcknowledgement *prev_queue;
+
+  /**
+   * If @e dvh is non-NULL, this is the DLL in which this acknowledgement
+   * is kept in relation to the DVH that was used to transmit the
+   * @a pm.
+   */
+  struct PendingAcknowledgement *next_dvh;
+
+  /**
+   * If @e dvh is non-NULL, this is the DLL in which this acknowledgement
+   * is kept in relation to the DVH that was used to transmit the
+   * @a pm.
+   */
+  struct PendingAcknowledgement *prev_dvh;
+
+  /**
+   * Pointers for the DLL of all pending acknowledgements.
+   * This list is sorted by @e transmission time.  If the list gets too
+   * long, the oldest entries are discarded.
+   */
+  struct PendingAcknowledgement *next_pa;
+
+  /**
+   * Pointers for the DLL of all pending acknowledgements.
+   * This list is sorted by @e transmission time.  If the list gets too
+   * long, the oldest entries are discarded.
+   */
+  struct PendingAcknowledgement *prev_pa;
+
+  /**
+   * Unique identifier for this transmission operation.
+   */
+  struct AcknowledgementUUIDP ack_uuid;
+
+  /**
+   * Message that was transmitted, may be NULL if the message was ACKed
+   * via another channel.
+   */
+  struct PendingMessage *pm;
+
+  /**
+   * Distance vector path chosen for this transmission, NULL if transmission
+   * was to a direct neighbour OR if the path was forgotten in the meantime.
+   */
+  struct DistanceVectorHop *dvh;
+
+  /**
+   * Queue used for transmission, NULL if the queue has been destroyed
+   * (which may happen before we get an acknowledgement).
+   */
+  struct Queue *queue;
+
+  /**
+   * Time of the transmission, for RTT calculation.
+   */
+  struct GNUNET_TIME_Absolute transmission_time;
+
+  /**
+   * Number of bytes of the original message (to calculate bandwidth).
+   */
+  uint16_t message_size;
+
+  /**
+   * How often the PendingMessage was send via the Queue of this PendingAcknowledgement.
+   */
+  unsigned int num_send;
+};
+
+
+/**
+ * One possible hop towards a DV target.
+ */
+struct DistanceVectorHop
+{
+  /**
+   * Kept in a MDLL, sorted by @e timeout.
+   */
+  struct DistanceVectorHop *next_dv;
+
+  /**
+   * Kept in a MDLL, sorted by @e timeout.
+   */
+  struct DistanceVectorHop *prev_dv;
+
+  /**
+   * Kept in a MDLL.
+   */
+  struct DistanceVectorHop *next_neighbour;
+
+  /**
+   * Kept in a MDLL.
+   */
+  struct DistanceVectorHop *prev_neighbour;
+
+  /**
+   * Head of DLL of PAs that used our @a path.
+   */
+  struct PendingAcknowledgement *pa_head;
+
+  /**
+   * Tail of DLL of PAs that used our @a path.
+   */
+  struct PendingAcknowledgement *pa_tail;
+
+  /**
+   * What would be the next hop to @e target?
+   */
+  struct Neighbour *next_hop;
+
+  /**
+   * Distance vector entry this hop belongs with.
+   */
+  struct DistanceVector *dv;
+
+  /**
+   * Array of @e distance hops to the target, excluding @e next_hop.
+   * NULL if the entire path is us to @e next_hop to `target`. Allocated
+   * at the end of this struct. Excludes the target itself!
+   */
+  const struct GNUNET_PeerIdentity *path;
+
+  /**
+   * At what time do we forget about this path unless we see it again
+   * while learning?
+   */
+  struct GNUNET_TIME_Absolute timeout;
+
+  /**
+   * For how long is the validation of this path considered
+   * valid?
+   * Set to ZERO if the path is learned by snooping on DV learn messages
+   * initiated by other peers, and to the time at which we generated the
+   * challenge for DV learn operations this peer initiated.
+   */
+  struct GNUNET_TIME_Absolute path_valid_until;
+
+  /**
+   * Performance data for this transmission possibility.
+   */
+  struct PerformanceData pd;
+
+  /**
+   * Number of hops in total to the `target` (excluding @e next_hop and `target`
+   * itself). Thus 0 still means a distance of 2 hops (to @e next_hop and then
+   * to `target`).
+   */
+  unsigned int distance;
+};
+
+
+/**
+ * Entry in our #dv_routes table, representing a (set of) distance
+ * vector routes to a particular peer.
+ */
+struct DistanceVector
+{
+  /**
+   * To which peer is this a route?
+   */
+  struct GNUNET_PeerIdentity target;
+
+  /**
+   * Known paths to @e target.
+   */
+  struct DistanceVectorHop *dv_head;
+
+  /**
+   * Known paths to @e target.
+   */
+  struct DistanceVectorHop *dv_tail;
+
+  /**
+   * Task scheduled to purge expired paths from @e dv_head MDLL.
+   */
+  struct GNUNET_SCHEDULER_Task *timeout_task;
+
+  /**
+   * Do we have a confirmed working queue and are thus visible to
+   * CORE?  If so, this is the virtual link, otherwise NULL.
+   */
+  struct VirtualLink *vl;
+
+  /**
+   * Signature affirming @e ephemeral_key of type
+   * #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL
+   */
+  struct GNUNET_CRYPTO_EddsaSignature sender_sig;
+
+  /**
+   * How long is @e sender_sig valid
+   */
+  struct GNUNET_TIME_Absolute ephemeral_validity;
+
+  /**
+   * What time was @e sender_sig created
+   */
+  struct GNUNET_TIME_Absolute monotime;
+
+  /**
+   * Our ephemeral key.
+   */
+  struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key;
+
+  /**
+   * Master secret for the setup of the Key material for the backchannel.
+   */
+  struct GNUNET_HashCode *km;
+};
+
+
+/**
+ * Entry identifying transmission in one of our `struct
+ * Queue` which still awaits an ACK.  This is used to
+ * ensure we do not overwhelm a communicator and limit the number of
+ * messages outstanding per communicator (say in case communicator is
+ * CPU bound) and per queue (in case bandwidth allocation exceeds
+ * what the communicator can actually provide towards a particular
+ * peer/target).
+ */
+struct QueueEntry
+{
+  /**
+   * Kept as a DLL.
+   */
+  struct QueueEntry *next;
+
+  /**
+   * Kept as a DLL.
+   */
+  struct QueueEntry *prev;
+
+  /**
+   * Queue this entry is queued with.
+   */
+  struct Queue *queue;
+
+  /**
+   * Pending message this entry is for, or NULL for none.
+   */
+  struct PendingMessage *pm;
+
+  /**
+   * Message ID used for this message with the queue used for transmission.
+   */
+  uint64_t mid;
+
+  /**
+   * Timestamp this QueueEntry was created.
+   */
+  struct GNUNET_TIME_Absolute creation_timestamp;
+};
+
+
+/**
+ * A queue is a message queue provided by a communicator
+ * via which we can reach a particular neighbour.
+ */
+struct Queue
+{
+  /**
+   * Kept in a MDLL.
+   */
+  struct Queue *next_neighbour;
+
+  /**
+   * Kept in a MDLL.
+   */
+  struct Queue *prev_neighbour;
+
+  /**
+   * Kept in a MDLL.
+   */
+  struct Queue *prev_client;
+
+  /**
+   * Kept in a MDLL.
+   */
+  struct Queue *next_client;
+
+  /**
+   * Head of DLL of PAs that used this queue.
+   */
+  struct PendingAcknowledgement *pa_head;
+
+  /**
+   * Tail of DLL of PAs that used this queue.
+   */
+  struct PendingAcknowledgement *pa_tail;
+
+  /**
+   * Head of DLL of unacked transmission requests.
+   */
+  struct QueueEntry *queue_head;
+
+  /**
+   * End of DLL of unacked transmission requests.
+   */
+  struct QueueEntry *queue_tail;
+
+  /**
+   * Which neighbour is this queue for?
+   */
+  struct Neighbour *neighbour;
+
+  /**
+   * Which communicator offers this queue?
+   */
+  struct TransportClient *tc;
+
+  /**
+   * Address served by the queue.
+   */
+  const char *address;
+
+  /**
+   * Is this queue of unlimited length.
+   */
+  unsigned int unlimited_length;
+
+  /**
+   * Task scheduled for the time when this queue can (likely) transmit the
+   * next message.
+   */
+  struct GNUNET_SCHEDULER_Task *transmit_task;
+
+  /**
+   * How long do *we* consider this @e address to be valid?  In the past or
+   * zero if we have not yet validated it.  Can be updated based on
+   * challenge-response validations (via address validation logic), or when we
+   * receive ACKs that we can definitively map to transmissions via this
+   * queue.
+   */
+  struct GNUNET_TIME_Absolute validated_until;
+
+  /**
+   * Performance data for this queue.
+   */
+  struct PerformanceData pd;
+
+  /**
+   * Handle for an operation to iterate through all hellos to compare the hello
+   * addresses with @e address which might be a natted one.
+   */
+  struct GNUNET_PEERSTORE_Monitor *mo;
+
+  /**
+   * Message ID generator for transmissions on this queue to the
+   * communicator.
+   */
+  uint64_t mid_gen;
+
+  /**
+   * Unique identifier of this queue with the communicator.
+   */
+  uint32_t qid;
+
+  /**
+   * Maximum transmission unit supported by this queue.
+   */
+  uint32_t mtu;
+
+  /**
+   * Messages pending.
+   */
+  uint32_t num_msg_pending;
+
+  /**
+   * Bytes pending.
+   */
+  uint32_t num_bytes_pending;
+
+  /**
+   * Length of the DLL starting at @e queue_head.
+   */
+  unsigned int queue_length;
+
+  /**
+   * Capacity of the queue.
+   */
+  uint64_t q_capacity;
+
+  /**
+   * Queue priority
+   */
+  uint32_t priority;
+
+  /**
+   * Network type offered by this queue.
+   */
+  enum GNUNET_NetworkType nt;
+
+  /**
+   * Connection status for this queue.
+   */
+  enum GNUNET_TRANSPORT_ConnectionStatus cs;
+
+  /**
+   * Set to #GNUNET_YES if this queue is idle waiting for some
+   * virtual link to give it a pending message.
+   */
+  int idle;
+
+  /**
+   * Set to GNUNET_yes, if this queues address is not a global natted one.
+   */
+  enum GNUNET_GenericReturnValue is_global_natted;
+};
+
+
+/**
+ * A neighbour that at least one communicator is connected to.
+ */
+struct Neighbour
+{
+  /**
+   * Which peer is this about?
+   */
+  struct GNUNET_PeerIdentity pid;
+
+  /**
+   * Head of MDLL of DV hops that have this neighbour as next hop. Must be
+   * purged if this neighbour goes down.
+   */
+  struct DistanceVectorHop *dv_head;
+
+  /**
+   * Tail of MDLL of DV hops that have this neighbour as next hop. Must be
+   * purged if this neighbour goes down.
+   */
+  struct DistanceVectorHop *dv_tail;
+
+  /**
+   * Head of DLL of queues to this peer.
+   */
+  struct Queue *queue_head;
+
+  /**
+   * Tail of DLL of queues to this peer.
+   */
+  struct Queue *queue_tail;
+
+  /**
+   * Handle for an operation to fetch @e last_dv_learn_monotime information from
+   * the PEERSTORE, or NULL.
+   */
+  struct GNUNET_PEERSTORE_IterateContext *get;
+
+  /**
+   * Handle to a PEERSTORE store operation to store this @e pid's @e
+   * @e last_dv_learn_monotime.  NULL if no PEERSTORE operation is pending.
+   */
+  struct GNUNET_PEERSTORE_StoreContext *sc;
+
+  /**
+   * Do we have a confirmed working queue and are thus visible to
+   * CORE?  If so, this is the virtual link, otherwise NULL.
+   */
+  struct VirtualLink *vl;
+
+  /**
+   * Latest DVLearn monotonic time seen from this peer.  Initialized only
+   * if @e dl_monotime_available is #GNUNET_YES.
+   */
+  struct GNUNET_TIME_Absolute last_dv_learn_monotime;
+
+  /**
+   * Do we have the latest value for @e last_dv_learn_monotime from
+   * PEERSTORE yet, or are we still waiting for a reply of PEERSTORE?
+   */
+  int dv_monotime_available;
+
+  /**
+   * Map of struct TransportGlobalNattedAddress for this neighbour.
+   */
+  struct GNUNET_CONTAINER_MultiPeerMap *natted_addresses;
+
+  /**
+   * Number of global natted addresses for this neighbour.
+   */
+  unsigned int number_of_addresses;
+
+  /**
+   * Size of all global natted addresses for this neighbour.
+   */
+  size_t size_of_global_addresses;
+
+  /**
+   * A queue of this neighbour has a global natted address.
+   */
+  enum GNUNET_GenericReturnValue is_global_natted;
+};
+
+
+/**
+ * Another peer attempted to talk to us, we should try to establish
+ * a connection in the other direction.
+ */
+struct IncomingRequest
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct IncomingRequest *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct IncomingRequest *prev;
+
+  /**
+   * Notify context for new HELLOs.
+   */
+  struct GNUNET_PEERSTORE_Monitor *nc;
+
+  /**
+   * Which peer is this about?
+   */
+  struct GNUNET_PeerIdentity pid;
+};
+
+
+/**
+ * A peer that an application (client) would like us to talk to directly.
+ */
+struct PeerRequest
+{
+  /**
+   * Which peer is this about?
+   */
+  struct GNUNET_PeerIdentity pid;
+
+  /**
+   * Client responsible for the request.
+   */
+  struct TransportClient *tc;
+
+  /**
+   * Notify context for new HELLOs.
+   */
+  struct GNUNET_PEERSTORE_Monitor *nc;
+
+  /**
+   * What kind of performance preference does this @e tc have?
+   *
+   * TODO: use this!
+   */
+  enum GNUNET_MQ_PriorityPreferences pk;
+
+  /**
+   * How much bandwidth would this @e tc like to see?
+   */
+  struct GNUNET_BANDWIDTH_Value32NBO bw;
+};
+
+
+/**
+ * Types of different pending messages.
+ */
+enum PendingMessageType
+{
+  /**
+   * Ordinary message received from the CORE service.
+   */
+  PMT_CORE = 0,
+
+  /**
+   * Fragment box.
+   */
+  PMT_FRAGMENT_BOX = 1,
+
+  /**
+   * Reliability box.
+   */
+  PMT_RELIABILITY_BOX = 2,
+
+  /**
+   * Pending message created during #forward_dv_box().
+   */
+  PMT_DV_BOX = 3
+};
+
+
+/**
+ * Transmission request that is awaiting delivery.  The original
+ * transmission requests from CORE may be too big for some queues.
+ * In this case, a *tree* of fragments is created.  At each
+ * level of the tree, fragments are kept in a DLL ordered by which
+ * fragment should be sent next (at the head).  The tree is searched
+ * top-down, with the original message at the root.
+ *
+ * To select a node for transmission, first it is checked if the
+ * current node's message fits with the MTU.  If it does not, we
+ * either calculate the next fragment (based on @e frag_off) from the
+ * current node, or, if all fragments have already been created,
+ * descend to the @e head_frag.  Even though the node was already
+ * fragmented, the fragment may be too big if the fragment was
+ * generated for a queue with a larger MTU. In this case, the node
+ * may be fragmented again, thus creating a tree.
+ *
+ * When acknowledgements for fragments are received, the tree
+ * must be pruned, removing those parts that were already
+ * acknowledged.  When fragments are sent over a reliable
+ * channel, they can be immediately removed.
+ *
+ * If a message is ever fragmented, then the original "full" message
+ * is never again transmitted (even if it fits below the MTU), and
+ * only (remaining) fragments are sent.
+ */
+struct PendingMessage
+{
+  /**
+   * Kept in a MDLL of messages for this @a vl.
+   */
+  struct PendingMessage *next_vl;
+
+  /**
+   * Kept in a MDLL of messages for this @a vl.
+   */
+  struct PendingMessage *prev_vl;
+
+  /**
+   * Kept in a MDLL of messages from this @a client (if @e pmt is #PMT_CORE)
+   */
+  struct PendingMessage *next_client;
+
+  /**
+   * Kept in a MDLL of messages from this @a client  (if @e pmt is #PMT_CORE)
+   */
+  struct PendingMessage *prev_client;
+
+  /**
+   * Kept in a MDLL of messages from this @a cpm (if @e pmt is
+   * #PMT_FRAGMENT_BOx)
+   */
+  struct PendingMessage *next_frag;
+
+  /**
+   * Kept in a MDLL of messages from this @a cpm  (if @e pmt is
+   * #PMT_FRAGMENT_BOX)
+   */
+  struct PendingMessage *prev_frag;
+
+  /**
+   * Head of DLL of PAs for this pending message.
+   */
+  struct PendingAcknowledgement *pa_head;
+
+  /**
+   * Tail of DLL of PAs for this pending message.
+   */
+  struct PendingAcknowledgement *pa_tail;
+
+  /**
+   * This message, reliability *or* DV-boxed. Only possibly available
+   * if @e pmt is #PMT_CORE.
+   */
+  struct PendingMessage *bpm;
+
+  /**
+   * Target of the request (always the ultimate destination!).
+   * Might be NULL in case of a forwarded DVBox we have no validated neighbour.
+   */
+  struct VirtualLink *vl;
+
+  /**
+   * In case of a not validated neighbour, we store the target peer.
+   **/
+  struct GNUNET_PeerIdentity target;
+
+  /**
+   * Set to non-NULL value if this message is currently being given to a
+   * communicator and we are awaiting that communicator's acknowledgement.
+   * Note that we must not retransmit a pending message while we're still
+   * in the process of giving it to a communicator. If a pending message
+   * is free'd while this entry is non-NULL, the @e qe reference to us
+   * should simply be set to NULL.
+   */
+  struct QueueEntry *qe;
+
+  /**
+   * Client that issued the transmission request, if @e pmt is #PMT_CORE.
+   */
+  struct TransportClient *client;
+
+  /**
+   * Head of a MDLL of fragments created for this core message.
+   */
+  struct PendingMessage *head_frag;
+
+  /**
+   * Tail of a MDLL of fragments created for this core message.
+   */
+  struct PendingMessage *tail_frag;
+
+  /**
+   * Our parent in the fragmentation tree.
+   */
+  struct PendingMessage *frag_parent;
+
+  /**
+   * At what time should we give up on the transmission (and no longer retry)?
+   */
+  struct GNUNET_TIME_Absolute timeout;
+
+  /**
+   * What is the earliest time for us to retry transmission of this message?
+   */
+  struct GNUNET_TIME_Absolute next_attempt;
+
+  /**
+   * UUID to use for this message (used for reassembly of fragments, only
+   * initialized if @e msg_uuid_set is #GNUNET_YES).
+   */
+  struct MessageUUIDP msg_uuid;
+
+  /**
+   * UUID we use to identify this message in our logs.
+   * Generated by incrementing the "logging_uuid_gen".
+   */
+  uint64_t logging_uuid;
+
+  /**
+   * Type of the pending message.
+   */
+  enum PendingMessageType pmt;
+
+  /**
+   * Preferences for this message.
+   * TODO: actually use this!
+   */
+  enum GNUNET_MQ_PriorityPreferences prefs;
+
+  /**
+   * If pmt is of type PMT_DV_BOX we store the used path here.
+   */
+  struct DistanceVectorHop *used_dvh;
+
+  /**
+   * Size of the original message.
+   */
+  uint16_t bytes_msg;
+
+  /**
+   * Offset at which we should generate the next fragment.
+   */
+  uint16_t frag_off;
+
+  /**
+   * Are we sending fragments at the moment?
+   */
+  uint32_t frags_in_flight;
+
+  /**
+   * The round we are (re)-sending fragments.
+   */
+  uint32_t frags_in_flight_round;
+
+  /**
+   * How many fragments do we have?
+   **/
+  uint16_t frag_count;
+
+  /**
+   * #GNUNET_YES once @e msg_uuid was initialized
+   */
+  int16_t msg_uuid_set;
+
+  /* Followed by @e bytes_msg to transmit */
+};
+
+
+/**
+ * Acknowledgement payload.
+ */
+struct TransportCummulativeAckPayload
+{
+  /**
+   * When did we receive the message we are ACKing?  Used to calculate
+   * the delay we introduced by cummulating ACKs.
+   */
+  struct GNUNET_TIME_Absolute receive_time;
+
+  /**
+   * UUID of a message being acknowledged.
+   */
+  struct AcknowledgementUUIDP ack_uuid;
+};
+
+
+/**
+ * Data structure in which we track acknowledgements still to
+ * be sent to the
+ */
+struct AcknowledgementCummulator
+{
+  /**
+   * Target peer for which we are accumulating ACKs here.
+   */
+  struct GNUNET_PeerIdentity target;
+
+  /**
+   * ACK data being accumulated.  Only @e num_acks slots are valid.
+   */
+  struct TransportCummulativeAckPayload ack_uuids[MAX_CUMMULATIVE_ACKS];
+
+  /**
+   * Task scheduled either to transmit the cumulative ACK message,
+   * or to clean up this data structure after extended periods of
+   * inactivity (if @e num_acks is zero).
+   */
+  struct GNUNET_SCHEDULER_Task *task;
+
+  /**
+   * When is @e task run (only used if @e num_acks is non-zero)?
+   */
+  struct GNUNET_TIME_Absolute min_transmission_time;
+
+  /**
+   * Counter to produce the `ack_counter` in the `struct
+   * TransportReliabilityAckMessage`.  Allows the receiver to detect
+   * lost ACK messages.  Incremented by @e num_acks upon transmission.
+   */
+  uint32_t ack_counter;
+
+  /**
+   * Number of entries used in @e ack_uuids.  Reset to 0 upon transmission.
+   */
+  unsigned int num_acks;
+};
+
+
+/**
+ * One of the addresses of this peer.
+ */
+struct AddressListEntry
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct AddressListEntry *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct AddressListEntry *prev;
+
+  /**
+   * Which communicator provides this address?
+   */
+  struct TransportClient *tc;
+
+  /**
+   * Store hello handle
+   */
+  struct GNUNET_PEERSTORE_StoreHelloContext *shc;
+
+  /**
+   * The actual address.
+   */
+  const char *address;
+
+  /**
+   * Signed address
+   */
+  void *signed_address;
+
+  /**
+   * Signed address length
+   */
+  size_t signed_address_len;
+
+  /**
+   * Current context for storing this address in the peerstore.
+   */
+  struct GNUNET_PEERSTORE_StoreContext *sc;
+
+  /**
+   * Task to periodically do @e st operation.
+   */
+  struct GNUNET_SCHEDULER_Task *st;
+
+  /**
+   * What is a typical lifetime the communicator expects this
+   * address to have? (Always from now.)
+   */
+  struct GNUNET_TIME_Relative expiration;
+
+  /**
+   * Address identifier used by the communicator.
+   */
+  uint32_t aid;
+
+  /**
+   * Network type offered by this address.
+   */
+  enum GNUNET_NetworkType nt;
+};
+
+
+/**
+ * Client connected to the transport service.
+ */
+struct TransportClient
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct TransportClient *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct TransportClient *prev;
+
+  /**
+   * Handle to the client.
+   */
+  struct GNUNET_SERVICE_Client *client;
+
+  /**
+   * Message queue to the client.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * What type of client is this?
+   */
+  enum ClientType type;
+
+  union
+  {
+    /**
+     * Information for @e type #CT_CORE.
+     */
+    struct
+    {
+      /**
+       * Head of list of messages pending for this client, sorted by
+       * transmission time ("next_attempt" + possibly internal prioritization).
+       */
+      struct PendingMessage *pending_msg_head;
+
+      /**
+       * Tail of list of messages pending for this client.
+       */
+      struct PendingMessage *pending_msg_tail;
+    } core;
+
+    /**
+     * Information for @e type #CT_MONITOR.
+     */
+    struct
+    {
+      /**
+       * Peer identity to monitor the addresses of.
+       * Zero to monitor all neighbours.  Valid if
+       * @e type is #CT_MONITOR.
+       */
+      struct GNUNET_PeerIdentity peer;
+
+      /**
+       * Is this a one-shot monitor?
+       */
+      int one_shot;
+    } monitor;
+
+
+    /**
+     * Information for @e type #CT_COMMUNICATOR.
+     */
+    struct
+    {
+      /**
+       * If @e type is #CT_COMMUNICATOR, this communicator
+       * supports communicating using these addresses.
+       */
+      char *address_prefix;
+
+      /**
+       * Head of DLL of queues offered by this communicator.
+       */
+      struct Queue *queue_head;
+
+      /**
+       * Tail of DLL of queues offered by this communicator.
+       */
+      struct Queue *queue_tail;
+
+      /**
+       * Head of list of the addresses of this peer offered by this
+       * communicator.
+       */
+      struct AddressListEntry *addr_head;
+
+      /**
+       * Tail of list of the addresses of this peer offered by this
+       * communicator.
+       */
+      struct AddressListEntry *addr_tail;
+
+      /**
+       * Number of queue entries in all queues to this communicator. Used
+       * throttle sending to a communicator if we see that the communicator
+       * is globally unable to keep up.
+       */
+      unsigned int total_queue_length;
+
+      /**
+       * Task to check for timed out QueueEntry.
+       */
+      struct GNUNET_SCHEDULER_Task *free_queue_entry_task;
+
+      /**
+       * Characteristics of this communicator.
+       */
+      enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc;
+    } communicator;
+
+    /**
+     * Information for @e type #CT_APPLICATION
+     */
+    struct
+    {
+      /**
+       * Map of requests for peers the given client application would like to
+       * see connections for.  Maps from PIDs to `struct PeerRequest`.
+       */
+      struct GNUNET_CONTAINER_MultiPeerMap *requests;
+    } application;
+  } details;
+};
+
+
+/**
+ * State we keep for validation activities.  Each of these
+ * is both in the #validation_heap and the #validation_map.
+ */
+struct ValidationState
+{
+  /**
+   * For which peer is @a address to be validated (or possibly valid)?
+   * Serves as key in the #validation_map.
+   */
+  struct GNUNET_PeerIdentity pid;
+
+  /**
+   * How long did the peer claim this @e address to be valid? Capped at
+   * minimum of #MAX_ADDRESS_VALID_UNTIL relative to the time where we last
+   * were told about the address and the value claimed by the other peer at
+   * that time.  May be updated similarly when validation succeeds.
+   */
+  struct GNUNET_TIME_Absolute valid_until;
+
+  /**
+   * How long do *we* consider this @e address to be valid?
+   * In the past or zero if we have not yet validated it.
+   */
+  struct GNUNET_TIME_Absolute validated_until;
+
+  /**
+   * When did we FIRST use the current @e challenge in a message?
+   * Used to sanity-check @code{origin_time} in the response when
+   * calculating the RTT. If the @code{origin_time} is not in
+   * the expected range, the response is discarded as malicious.
+   */
+  struct GNUNET_TIME_Absolute first_challenge_use;
+
+  /**
+   * When did we LAST use the current @e challenge in a message?
+   * Used to sanity-check @code{origin_time} in the response when
+   * calculating the RTT.  If the @code{origin_time} is not in
+   * the expected range, the response is discarded as malicious.
+   */
+  struct GNUNET_TIME_Absolute last_challenge_use;
+
+  /**
+   * Next time we will send the @e challenge to the peer, if this time is past
+   * @e valid_until, this validation state is released at this time.  If the
+   * address is valid, @e next_challenge is set to @e validated_until MINUS @e
+   * validation_delay * #VALIDATION_RTT_BUFFER_FACTOR, such that we will try
+   * to re-validate before the validity actually expires.
+   */
+  struct GNUNET_TIME_Absolute next_challenge;
+
+  /**
+   * Current backoff factor we're applying for sending the @a challenge.
+   * Reset to 0 if the @a challenge is confirmed upon validation.
+   * Reduced to minimum of #FAST_VALIDATION_CHALLENGE_FREQ and half of the
+   * existing value if we receive an unvalidated address again over
+   * another channel (and thus should consider the information "fresh").
+   * Maximum is #MAX_VALIDATION_CHALLENGE_FREQ.
+   */
+  struct GNUNET_TIME_Relative challenge_backoff;
+
+  /**
+   * Initially set to "forever". Once @e validated_until is set, this value is
+   * set to the RTT that tells us how long it took to receive the validation.
+   */
+  struct GNUNET_TIME_Relative validation_rtt;
+
+  /**
+   * The challenge we sent to the peer to get it to validate the address. Note
+   * that we rotate the challenge whenever we update @e validated_until to
+   * avoid attacks where a peer simply replays an old challenge in the future.
+   * (We must not rotate more often as otherwise we may discard valid answers
+   * due to packet losses, latency and reorderings on the network).
+   */
+  struct GNUNET_CRYPTO_ChallengeNonceP challenge;
+
+  /**
+   * Hascode key to store state in a map.
+   */
+  struct GNUNET_HashCode hc;
+
+  /**
+   * Task to revalidate this address.
+   */
+  struct GNUNET_SCHEDULER_Task *revalidation_task;
+
+  /**
+   * Claimed address of the peer.
+   */
+  char *address;
+
+  /**
+   * Entry in the #validation_heap, which is sorted by @e next_challenge. The
+   * heap is used to figure out when the next validation activity should be
+   * run.
+   */
+  struct GNUNET_CONTAINER_HeapNode *hn;
+
+  /**
+   * Handle to a PEERSTORE store operation for this @e address.  NULL if
+   * no PEERSTORE operation is pending.
+   */
+  struct GNUNET_PEERSTORE_StoreContext *sc;
+
+  /**
+   * Self-imposed limit on the previous flow control window. (May be zero,
+   * if we never used data from the previous window or are establishing the
+   * connection for the first time).
+   */
+  uint32_t last_window_consum_limit;
+
+  /**
+   * We are technically ready to send the challenge, but we are waiting for
+   * the respective queue to become available for transmission.
+   */
+  int awaiting_queue;
+};
+
+
+/**
+ * A Backtalker is a peer sending us backchannel messages. We use this
+ * struct to detect monotonic time violations, cache ephemeral key
+ * material (to avoid repeatedly checking signatures), and to synchronize
+ * monotonic time with the PEERSTORE.
+ */
+struct Backtalker
+{
+  /**
+   * Peer this is about.
+   */
+  struct GNUNET_PeerIdentity pid;
+
+  /**
+   * Last (valid) monotonic time received from this sender.
+   */
+  struct GNUNET_TIME_Absolute monotonic_time;
+
+  /**
+   * When will this entry time out?
+   */
+  struct GNUNET_TIME_Absolute timeout;
+
+  /**
+   * Last (valid) ephemeral key received from this sender.
+   */
+  struct GNUNET_CRYPTO_EcdhePublicKey last_ephemeral;
+
+  /**
+   * Task associated with this backtalker. Can be for timeout,
+   * or other asynchronous operations.
+   */
+  struct GNUNET_SCHEDULER_Task *task;
+
+  /**
+   * Communicator context waiting on this backchannel's @e get, or NULL.
+   */
+  struct CommunicatorMessageContext *cmc;
+
+  /**
+   * Handle for an operation to fetch @e monotonic_time information from the
+   * PEERSTORE, or NULL.
+   */
+  struct GNUNET_PEERSTORE_IterateContext *get;
+
+  /**
+   * Handle to a PEERSTORE store operation for this @e pid's @e
+   * monotonic_time.  NULL if no PEERSTORE operation is pending.
+   */
+  struct GNUNET_PEERSTORE_StoreContext *sc;
+
+  /**
+   * Number of bytes of the original message body that follows after this
+   * struct.
+   */
+  size_t body_size;
+};
+
+/**
+ * Ring buffer for a CORE message we did not deliver to CORE, because of missing virtual link to sender.
+ */
+static struct RingBufferEntry *ring_buffer[RING_BUFFER_SIZE];
+
+/**
+ * Head of the ring buffer.
+ */
+static unsigned int ring_buffer_head;
+
+/**
+ * Is the ring buffer filled up to RING_BUFFER_SIZE.
+ */
+static unsigned int is_ring_buffer_full;
+
+/**
+ * Ring buffer for a forwarded DVBox message we did not deliver to the next hop, because of missing virtual link that hop.
+ */
+static struct PendingMessage *ring_buffer_dv[RING_BUFFER_SIZE];
+
+/**
+ * Head of the ring buffer.
+ */
+static unsigned int ring_buffer_dv_head;
+
+/**
+ * Is the ring buffer filled up to RING_BUFFER_SIZE.
+ */
+static unsigned int is_ring_buffer_dv_full;
+
+/**
+ * Head of linked list of all clients to this service.
+ */
+static struct TransportClient *clients_head;
+
+/**
+ * Tail of linked list of all clients to this service.
+ */
+static struct TransportClient *clients_tail;
+
+/**
+ * Statistics handle.
+ */
+static struct GNUNET_STATISTICS_Handle *GST_stats;
+
+/**
+ * Configuration handle.
+ */
+static const struct GNUNET_CONFIGURATION_Handle *GST_cfg;
+
+/**
+ * Our public key.
+ */
+static struct GNUNET_PeerIdentity GST_my_identity;
+
+/**
+ * Our HELLO
+ */
+struct GNUNET_HELLO_Builder *GST_my_hello;
+
+/**
+ * Our private key.
+ */
+static struct GNUNET_CRYPTO_EddsaPrivateKey *GST_my_private_key;
+
+/**
+ * Map from PIDs to `struct Neighbour` entries.  A peer is
+ * a neighbour if we have an MQ to it from some communicator.
+ */
+static struct GNUNET_CONTAINER_MultiPeerMap *neighbours;
+
+/**
+ * Map from PIDs to `struct Backtalker` entries.  A peer is
+ * a backtalker if it recently send us backchannel messages.
+ */
+static struct GNUNET_CONTAINER_MultiPeerMap *backtalkers;
+
+/**
+ * Map from PIDs to `struct AcknowledgementCummulator`s.
+ * Here we track the cumulative ACKs for transmission.
+ */
+static struct GNUNET_CONTAINER_MultiPeerMap *ack_cummulators;
+
+/**
+ * Map of pending acknowledgements, mapping `struct AcknowledgementUUID` to
+ * a `struct PendingAcknowledgement`.
+ */
+static struct GNUNET_CONTAINER_MultiUuidmap *pending_acks;
+
+/**
+ * Map from PIDs to `struct DistanceVector` entries describing
+ * known paths to the peer.
+ */
+static struct GNUNET_CONTAINER_MultiPeerMap *dv_routes;
+
+/**
+ * Map from PIDs to `struct ValidationState` entries describing
+ * addresses we are aware of and their validity state.
+ */
+static struct GNUNET_CONTAINER_MultiPeerMap *validation_map;
+
+/**
+ * Map from addresses to `struct ValidationState` entries describing
+ * addresses we are aware of and their validity state.
+ */
+static struct GNUNET_CONTAINER_MultiHashMap *revalidation_map;
+
+/**
+ * Map from PIDs to `struct VirtualLink` entries describing
+ * links CORE knows to exist.
+ */
+static struct GNUNET_CONTAINER_MultiPeerMap *links;
+
+/**
+ * Map from challenges to `struct LearnLaunchEntry` values.
+ */
+static struct GNUNET_CONTAINER_MultiShortmap *dvlearn_map;
+
+/**
+ * Head of a DLL sorted by launch time.
+ */
+static struct LearnLaunchEntry *lle_head = NULL;
+
+/**
+ * Tail of a DLL sorted by launch time.
+ */
+static struct LearnLaunchEntry *lle_tail = NULL;
+
+/**
+ * MIN Heap sorted by "next_challenge" to `struct ValidationState` entries
+ * sorting addresses we are aware of by when we should next try to (re)validate
+ * (or expire) them.
+ */
+static struct GNUNET_CONTAINER_Heap *validation_heap;
+
+/**
+ * Handle for connect to the NAT service.
+ */
+struct GNUNET_NAT_Handle *nh;
+
+/**
+ * Database for peer's HELLOs.
+ */
+static struct GNUNET_PEERSTORE_Handle *peerstore;
+
+/**
+ * Task run to initiate DV learning.
+ */
+static struct GNUNET_SCHEDULER_Task *dvlearn_task;
+
+/**
+ * Task to run address validation.
+ */
+static struct GNUNET_SCHEDULER_Task *validation_task;
+
+/**
+ * List of incoming connections where we are trying
+ * to get a connection back established. Length
+ * kept in #ir_total.
+ */
+static struct IncomingRequest *ir_head;
+
+/**
+ * Tail of DLL starting at #ir_head.
+ */
+static struct IncomingRequest *ir_tail;
+
+/**
+ * Length of the DLL starting at #ir_head.
+ */
+static unsigned int ir_total;
+
+/**
+ * Generator of `logging_uuid` in `struct PendingMessage`.
+ */
+static unsigned long long logging_uuid_gen;
+
+/**
+ * Monotonic time we use for HELLOs generated at this time.  TODO: we
+ * should increase this value from time to time (i.e. whenever a
+ * `struct AddressListEntry` actually expires), but IF we do this, we
+ * must also update *all* (remaining) addresses in the PEERSTORE at
+ * that time! (So for now only increased when the peer is restarted,
+ * which hopefully roughly matches whenever our addresses change.)
+ */
+static struct GNUNET_TIME_Absolute hello_mono_time;
+
+/**
+ * Indication if we have received a shutdown signal
+ * and are in the process of cleaning up.
+ */
+static int in_shutdown;
+
+/**
+ * Get an offset into the transmission history buffer for `struct
+ * PerformanceData`.  Note that the caller must perform the required
+ * modulo #GOODPUT_AGING_SLOTS operation before indexing into the
+ * array!
+ *
+ * An 'age' lasts 15 minute slots.
+ *
+ * @return current age of the world
+ */
+static unsigned int
+get_age ()
+{
+  struct GNUNET_TIME_Absolute now;
+
+  now = GNUNET_TIME_absolute_get ();
+  return now.abs_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us / 15;
+}
+
+
+/**
+ * Release @a ir data structure.
+ *
+ * @param ir data structure to release
+ */
+static void
+free_incoming_request (struct IncomingRequest *ir)
+{
+  GNUNET_CONTAINER_DLL_remove (ir_head, ir_tail, ir);
+  GNUNET_assert (ir_total > 0);
+  ir_total--;
+  if (NULL != ir->nc)
+    GNUNET_PEERSTORE_monitor_stop (ir->nc);
+  ir->nc = NULL;
+  GNUNET_free (ir);
+}
+
+
+/**
+ * Release @a pa data structure.
+ *
+ * @param pa data structure to release
+ */
+static void
+free_pending_acknowledgement (struct PendingAcknowledgement *pa)
+{
+  struct Queue *q = pa->queue;
+  struct PendingMessage *pm = pa->pm;
+  struct DistanceVectorHop *dvh = pa->dvh;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "free_pending_acknowledgement\n");
+  if (NULL != q)
+  {
+    GNUNET_CONTAINER_MDLL_remove (queue, q->pa_head, q->pa_tail, pa);
+    pa->queue = NULL;
+  }
+  if (NULL != pm)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "remove pa from message\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "remove pa from message %" PRIu64 "\n",
+                pm->logging_uuid);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "remove pa from message %u\n",
+                pm->pmt);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "remove pa from message %s\n",
+                GNUNET_uuid2s (&pa->ack_uuid.value));
+    GNUNET_CONTAINER_MDLL_remove (pm, pm->pa_head, pm->pa_tail, pa);
+    pa->pm = NULL;
+  }
+  if (NULL != dvh)
+  {
+    GNUNET_CONTAINER_MDLL_remove (dvh, dvh->pa_head, dvh->pa_tail, pa);
+    pa->queue = NULL;
+  }
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multiuuidmap_remove (pending_acks,
+                                                       &pa->ack_uuid.value,
+                                                       pa));
+  GNUNET_free (pa);
+}
+
+
+/**
+ * Free fragment tree below @e root, excluding @e root itself.
+ * FIXME: this does NOT seem to have the intended semantics
+ * based on how this is called. Seems we generally DO expect
+ * @a root to be free'ed itself as well!
+ *
+ * @param root root of the tree to free
+ */
+static void
+free_fragment_tree (struct PendingMessage *root)
+{
+  struct PendingMessage *frag;
+
+  while (NULL != (frag = root->head_frag))
+  {
+    struct PendingAcknowledgement *pa;
+
+    free_fragment_tree (frag);
+    while (NULL != (pa = frag->pa_head))
+    {
+      GNUNET_CONTAINER_MDLL_remove (pm, frag->pa_head, frag->pa_tail, pa);
+      pa->pm = NULL;
+    }
+    GNUNET_CONTAINER_MDLL_remove (frag, root->head_frag, root->tail_frag, frag);
+    if (NULL != frag->qe)
+    {
+      GNUNET_assert (frag == frag->qe->pm);
+      frag->qe->pm = NULL;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Free frag %p\n",
+                frag);
+    GNUNET_free (frag);
+  }
+}
+
+
+/**
+ * Release memory associated with @a pm and remove @a pm from associated
+ * data structures.  @a pm must be a top-level pending message and not
+ * a fragment in the tree.  The entire tree is freed (if applicable).
+ *
+ * @param pm the pending message to free
+ */
+static void
+free_pending_message (struct PendingMessage *pm)
+{
+  struct TransportClient *tc = pm->client;
+  struct VirtualLink *vl = pm->vl;
+  struct PendingAcknowledgement *pa;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Freeing pm %p\n",
+              pm);
+  if (NULL != tc)
+  {
+    GNUNET_CONTAINER_MDLL_remove (client,
+                                  tc->details.core.pending_msg_head,
+                                  tc->details.core.pending_msg_tail,
+                                  pm);
+  }
+  if ((NULL != vl) && (NULL == pm->frag_parent))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Removing pm %" PRIu64 "\n",
+                pm->logging_uuid);
+    GNUNET_CONTAINER_MDLL_remove (vl,
+                                  vl->pending_msg_head,
+                                  vl->pending_msg_tail,
+                                  pm);
+  }
+  else if (NULL != pm->frag_parent && PMT_DV_BOX != pm->pmt)
+  {
+    struct PendingMessage *root = pm->frag_parent;
+
+    while (NULL != root->frag_parent && PMT_DV_BOX != root->pmt)
+      root = root->frag_parent;
+
+    root->frag_count--;
+  }
+  while (NULL != (pa = pm->pa_head))
+  {
+    if (NULL == pa)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "free pending pa  null\n");
+    if (NULL == pm->pa_tail)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "free pending pa_tail null\n");
+    if (NULL == pa->prev_pa)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "free pending pa prev null\n");
+    if (NULL == pa->next_pa)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "free pending pa next null\n");
+    GNUNET_CONTAINER_MDLL_remove (pm, pm->pa_head, pm->pa_tail, pa);
+    pa->pm = NULL;
+  }
+
+  free_fragment_tree (pm);
+  if (NULL != pm->qe)
+  {
+    GNUNET_assert (pm == pm->qe->pm);
+    pm->qe->pm = NULL;
+  }
+  if (NULL != pm->bpm)
+  {
+    free_fragment_tree (pm->bpm);
+    if (NULL != pm->bpm->qe)
+    {
+      struct QueueEntry *qe = pm->bpm->qe;
+
+      qe->pm = NULL;
+    }
+    GNUNET_free (pm->bpm);
+  }
+
+  GNUNET_free (pm);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Freeing pm done\n");
+}
+
+
+/**
+ * Free @a rc
+ *
+ * @param rc data structure to free
+ */
+static void
+free_reassembly_context (struct ReassemblyContext *rc)
+{
+  struct VirtualLink *vl = rc->virtual_link;
+
+  GNUNET_assert (rc == GNUNET_CONTAINER_heap_remove_node (rc->hn));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multihashmap32_remove (vl->reassembly_map,
+                                                         rc->msg_uuid.uuid,
+                                                         rc));
+  GNUNET_free (rc);
+}
+
+
+/**
+ * Task run to clean up reassembly context of a neighbour that have expired.
+ *
+ * @param cls a `struct Neighbour`
+ */
+static void
+reassembly_cleanup_task (void *cls)
+{
+  struct VirtualLink *vl = cls;
+  struct ReassemblyContext *rc;
+
+  vl->reassembly_timeout_task = NULL;
+  while (NULL != (rc = GNUNET_CONTAINER_heap_peek (vl->reassembly_heap)))
+  {
+    if (0 == GNUNET_TIME_absolute_get_remaining (rc->reassembly_timeout)
+        .rel_value_us)
+    {
+      free_reassembly_context (rc);
+      continue;
+    }
+    GNUNET_assert (NULL == vl->reassembly_timeout_task);
+    vl->reassembly_timeout_task =
+      GNUNET_SCHEDULER_add_at (rc->reassembly_timeout,
+                               &reassembly_cleanup_task,
+                               vl);
+    return;
+  }
+}
+
+
+/**
+ * function called to #free_reassembly_context().
+ *
+ * @param cls NULL
+ * @param key unused
+ * @param value a `struct ReassemblyContext` to free
+ * @return #GNUNET_OK (continue iteration)
+ */
+static int
+free_reassembly_cb (void *cls, uint32_t key, void *value)
+{
+  struct ReassemblyContext *rc = value;
+
+  (void) cls;
+  (void) key;
+  free_reassembly_context (rc);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Free virtual link.
+ *
+ * @param vl link data to free
+ */
+static void
+free_virtual_link (struct VirtualLink *vl)
+{
+  struct PendingMessage *pm;
+  struct CoreSentContext *csc;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "free virtual link %p\n",
+              vl);
+
+  if (NULL != vl->reassembly_map)
+  {
+    GNUNET_CONTAINER_multihashmap32_iterate (vl->reassembly_map,
+                                             &free_reassembly_cb,
+                                             NULL);
+    GNUNET_CONTAINER_multihashmap32_destroy (vl->reassembly_map);
+    vl->reassembly_map = NULL;
+    GNUNET_CONTAINER_heap_destroy (vl->reassembly_heap);
+    vl->reassembly_heap = NULL;
+  }
+  if (NULL != vl->reassembly_timeout_task)
+  {
+    GNUNET_SCHEDULER_cancel (vl->reassembly_timeout_task);
+    vl->reassembly_timeout_task = NULL;
+  }
+  while (NULL != (pm = vl->pending_msg_head))
+    free_pending_message (pm);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multipeermap_remove (links, &vl->target, vl));
+  if (NULL != vl->visibility_task)
+  {
+    GNUNET_SCHEDULER_cancel (vl->visibility_task);
+    vl->visibility_task = NULL;
+  }
+  if (NULL != vl->fc_retransmit_task)
+  {
+    GNUNET_SCHEDULER_cancel (vl->fc_retransmit_task);
+    vl->fc_retransmit_task = NULL;
+  }
+  while (NULL != (csc = vl->csc_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (vl->csc_head, vl->csc_tail, csc);
+    GNUNET_assert (vl == csc->vl);
+    csc->vl = NULL;
+  }
+  GNUNET_break (NULL == vl->n);
+  GNUNET_break (NULL == vl->dv);
+  GNUNET_free (vl);
+}
+
+
+/**
+ * Free validation state.
+ *
+ * @param vs validation state to free
+ */
+static void
+free_validation_state (struct ValidationState *vs)
+{
+  if (NULL != vs->revalidation_task)
+  {
+    GNUNET_SCHEDULER_cancel (vs->revalidation_task);
+    vs->revalidation_task = NULL;
+  }
+  /*memcpy (&hkey,
+          &hc,
+          sizeof (hkey));*/
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Remove key %s for address %s map size %u contains %u during freeing state\n",
+              GNUNET_h2s (&vs->hc),
+              vs->address,
+              GNUNET_CONTAINER_multihashmap_size (revalidation_map),
+              GNUNET_CONTAINER_multihashmap_contains (revalidation_map,
+                                                      &vs->hc));
+  GNUNET_CONTAINER_multihashmap_remove (revalidation_map, &vs->hc, vs);
+  GNUNET_assert (
+    GNUNET_YES ==
+    GNUNET_CONTAINER_multipeermap_remove (validation_map, &vs->pid, vs));
+  GNUNET_CONTAINER_heap_remove_node (vs->hn);
+  vs->hn = NULL;
+  if (NULL != vs->sc)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "store cancel\n");
+    GNUNET_PEERSTORE_store_cancel (vs->sc);
+    vs->sc = NULL;
+  }
+  GNUNET_free (vs->address);
+  GNUNET_free (vs);
+}
+
+
+/**
+ * Lookup neighbour for peer @a pid.
+ *
+ * @param pid neighbour to look for
+ * @return NULL if we do not have this peer as a neighbour
+ */
+static struct Neighbour *
+lookup_neighbour (const struct GNUNET_PeerIdentity *pid)
+{
+  return GNUNET_CONTAINER_multipeermap_get (neighbours, pid);
+}
+
+
+/**
+ * Lookup virtual link for peer @a pid.
+ *
+ * @param pid virtual link to look for
+ * @return NULL if we do not have this peer as a virtual link
+ */
+static struct VirtualLink *
+lookup_virtual_link (const struct GNUNET_PeerIdentity *pid)
+{
+  return GNUNET_CONTAINER_multipeermap_get (links, pid);
+}
+
+
+/**
+ * Details about what to notify monitors about.
+ */
+struct MonitorEvent
+{
+  /**
+   * @deprecated To be discussed if we keep these...
+   */
+  struct GNUNET_TIME_Absolute last_validation;
+  struct GNUNET_TIME_Absolute valid_until;
+  struct GNUNET_TIME_Absolute next_validation;
+
+  /**
+   * Current round-trip time estimate.
+   */
+  struct GNUNET_TIME_Relative rtt;
+
+  /**
+   * Connection status.
+   */
+  enum GNUNET_TRANSPORT_ConnectionStatus cs;
+
+  /**
+   * Messages pending.
+   */
+  uint32_t num_msg_pending;
+
+  /**
+   * Bytes pending.
+   */
+  uint32_t num_bytes_pending;
+};
+
+
+/**
+ * Free a @a dvh. Callers MAY want to check if this was the last path to the
+ * `target`, and if so call #free_dv_route to also free the associated DV
+ * entry in #dv_routes (if not, the associated scheduler job should eventually
+ * take care of it).
+ *
+ * @param dvh hop to free
+ */
+static void
+free_distance_vector_hop (struct DistanceVectorHop *dvh)
+{
+  struct Neighbour *n = dvh->next_hop;
+  struct DistanceVector *dv = dvh->dv;
+  struct PendingAcknowledgement *pa;
+
+  while (NULL != (pa = dvh->pa_head))
+  {
+    GNUNET_CONTAINER_MDLL_remove (dvh, dvh->pa_head, dvh->pa_tail, pa);
+    pa->dvh = NULL;
+  }
+  GNUNET_CONTAINER_MDLL_remove (neighbour, n->dv_head, n->dv_tail, dvh);
+  GNUNET_CONTAINER_MDLL_remove (dv, dv->dv_head, dv->dv_tail, dvh);
+  GNUNET_free (dvh);
+}
+
+
+/**
+ * Task run to check whether the hops of the @a cls still
+ * are validated, or if we need to core about disconnection.
+ *
+ * @param cls a `struct VirtualLink`
+ */
+static void
+check_link_down (void *cls);
+
+
+/**
+ * Send message to CORE clients that we lost a connection.
+ *
+ * @param pid peer the connection was for
+ */
+static void
+cores_send_disconnect_info (const struct GNUNET_PeerIdentity *pid)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Informing CORE clients about disconnect from %s\n",
+              GNUNET_i2s (pid));
+  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
+  {
+    struct GNUNET_MQ_Envelope *env;
+    struct DisconnectInfoMessage *dim;
+
+    if (CT_CORE != tc->type)
+      continue;
+    env = GNUNET_MQ_msg (dim, GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT);
+    dim->peer = *pid;
+    GNUNET_MQ_send (tc->mq, env);
+  }
+}
+
+
+/**
+ * Free entry in #dv_routes.  First frees all hops to the target, and
+ * if there are no entries left, frees @a dv as well.
+ *
+ * @param dv route to free
+ */
+static void
+free_dv_route (struct DistanceVector *dv)
+{
+  struct DistanceVectorHop *dvh;
+
+  while (NULL != (dvh = dv->dv_head))
+    free_distance_vector_hop (dvh);
+  if (NULL == dv->dv_head)
+  {
+    struct VirtualLink *vl;
+
+    GNUNET_assert (
+      GNUNET_YES ==
+      GNUNET_CONTAINER_multipeermap_remove (dv_routes, &dv->target, dv));
+    if (NULL != (vl = dv->vl))
+    {
+      GNUNET_assert (dv == vl->dv);
+      vl->dv = NULL;
+      if (NULL == vl->n)
+      {
+        cores_send_disconnect_info (&dv->target);
+        free_virtual_link (vl);
+      }
+      else
+      {
+        GNUNET_SCHEDULER_cancel (vl->visibility_task);
+        vl->visibility_task = GNUNET_SCHEDULER_add_now (&check_link_down, vl);
+      }
+      dv->vl = NULL;
+    }
+
+    if (NULL != dv->timeout_task)
+    {
+      GNUNET_SCHEDULER_cancel (dv->timeout_task);
+      dv->timeout_task = NULL;
+    }
+    GNUNET_free (dv->km);
+    GNUNET_free (dv);
+  }
+}
+
+
+/**
+ * Notify monitor @a tc about an event.  That @a tc
+ * cares about the event has already been checked.
+ *
+ * Send @a tc information in @a me about a @a peer's status with
+ * respect to some @a address to all monitors that care.
+ *
+ * @param tc monitor to inform
+ * @param peer peer the information is about
+ * @param address address the information is about
+ * @param nt network type associated with @a address
+ * @param me detailed information to transmit
+ */
+static void
+notify_monitor (struct TransportClient *tc,
+                const struct GNUNET_PeerIdentity *peer,
+                const char *address,
+                enum GNUNET_NetworkType nt,
+                const struct MonitorEvent *me)
+{
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_TRANSPORT_MonitorData *md;
+  size_t addr_len = strlen (address) + 1;
+
+  env = GNUNET_MQ_msg_extra (md,
+                             addr_len,
+                             GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA);
+  md->nt = htonl ((uint32_t) nt);
+  md->peer = *peer;
+  md->last_validation = GNUNET_TIME_absolute_hton (me->last_validation);
+  md->valid_until = GNUNET_TIME_absolute_hton (me->valid_until);
+  md->next_validation = GNUNET_TIME_absolute_hton (me->next_validation);
+  md->rtt = GNUNET_TIME_relative_hton (me->rtt);
+  md->cs = htonl ((uint32_t) me->cs);
+  md->num_msg_pending = htonl (me->num_msg_pending);
+  md->num_bytes_pending = htonl (me->num_bytes_pending);
+  memcpy (&md[1], address, addr_len);
+  GNUNET_MQ_send (tc->mq, env);
+}
+
+
+/**
+ * Send information in @a me about a @a peer's status with respect
+ * to some @a address to all monitors that care.
+ *
+ * @param peer peer the information is about
+ * @param address address the information is about
+ * @param nt network type associated with @a address
+ * @param me detailed information to transmit
+ */
+static void
+notify_monitors (const struct GNUNET_PeerIdentity *peer,
+                 const char *address,
+                 enum GNUNET_NetworkType nt,
+                 const struct MonitorEvent *me)
+{
+  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
+  {
+    if (CT_MONITOR != tc->type)
+      continue;
+    if (tc->details.monitor.one_shot)
+      continue;
+    if ((GNUNET_NO == GNUNET_is_zero (&tc->details.monitor.peer)) &&
+        (0 != GNUNET_memcmp (&tc->details.monitor.peer, peer)))
+      continue;
+    notify_monitor (tc, peer, address, nt, me);
+  }
+}
+
+
+/**
+ * Called whenever a client connects.  Allocates our
+ * data structures associated with that client.
+ *
+ * @param cls closure, NULL
+ * @param client identification of the client
+ * @param mq message queue for the client
+ * @return our `struct TransportClient`
+ */
+static void *
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *client,
+                   struct GNUNET_MQ_Handle *mq)
+{
+  struct TransportClient *tc;
+
+  (void) cls;
+  tc = GNUNET_new (struct TransportClient);
+  tc->client = client;
+  tc->mq = mq;
+  GNUNET_CONTAINER_DLL_insert (clients_head, clients_tail, tc);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Client %p of type %u connected\n",
+              tc,
+              tc->type);
+  return tc;
+}
+
+
+static enum GNUNET_GenericReturnValue
+remove_global_addresses (void *cls,
+                         const struct GNUNET_PeerIdentity *pid,
+                         void *value)
+{
+  (void) cls;
+  struct TransportGlobalNattedAddress *tgna = value;
+
+  GNUNET_free (tgna);
+
+  return GNUNET_OK;
+}
+
+
+/**
+ * Release memory used by @a neighbour.
+ *
+ * @param neighbour neighbour entry to free
+ */
+static void
+free_neighbour (struct Neighbour *neighbour)
+{
+  struct DistanceVectorHop *dvh;
+  struct VirtualLink *vl;
+
+  GNUNET_assert (NULL == neighbour->queue_head);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multipeermap_remove (neighbours,
+                                                       &neighbour->pid,
+                                                       neighbour));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Freeing neighbour\n");
+  GNUNET_CONTAINER_multipeermap_iterate (neighbour->natted_addresses,
+                                         &remove_global_addresses,
+                                         NULL);
+  GNUNET_CONTAINER_multipeermap_destroy (neighbour->natted_addresses);
+  while (NULL != (dvh = neighbour->dv_head))
+  {
+    struct DistanceVector *dv = dvh->dv;
+
+    free_distance_vector_hop (dvh);
+    if (NULL == dv->dv_head)
+      free_dv_route (dv);
+  }
+  if (NULL != neighbour->get)
+  {
+    GNUNET_PEERSTORE_iteration_stop (neighbour->get);
+    neighbour->get = NULL;
+  }
+  if (NULL != neighbour->sc)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "store cancel\n");
+    GNUNET_PEERSTORE_store_cancel (neighbour->sc);
+    neighbour->sc = NULL;
+  }
+  if (NULL != (vl = neighbour->vl))
+  {
+    GNUNET_assert (neighbour == vl->n);
+    vl->n = NULL;
+    if (NULL == vl->dv)
+    {
+      cores_send_disconnect_info (&vl->target);
+      free_virtual_link (vl);
+    }
+    else
+    {
+      GNUNET_SCHEDULER_cancel (vl->visibility_task);
+      vl->visibility_task = GNUNET_SCHEDULER_add_now (&check_link_down, vl);
+    }
+    neighbour->vl = NULL;
+  }
+  GNUNET_free (neighbour);
+}
+
+
+/**
+ * Send message to CORE clients that we lost a connection.
+ *
+ * @param tc client to inform (must be CORE client)
+ * @param pid peer the connection is for
+ */
+static void
+core_send_connect_info (struct TransportClient *tc,
+                        const struct GNUNET_PeerIdentity *pid)
+{
+  struct GNUNET_MQ_Envelope *env;
+  struct ConnectInfoMessage *cim;
+
+  GNUNET_assert (CT_CORE == tc->type);
+  env = GNUNET_MQ_msg (cim, GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT);
+  cim->id = *pid;
+  GNUNET_MQ_send (tc->mq, env);
+}
+
+
+/**
+ * Send message to CORE clients that we gained a connection
+ *
+ * @param pid peer the queue was for
+ */
+static void
+cores_send_connect_info (const struct GNUNET_PeerIdentity *pid)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Informing CORE clients about connection to %s\n",
+              GNUNET_i2s (pid));
+  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
+  {
+    if (CT_CORE != tc->type)
+      continue;
+    core_send_connect_info (tc, pid);
+  }
+}
+
+
+/**
+ * We believe we are ready to transmit a message on a queue. Gives the
+ * message to the communicator for transmission (updating the tracker,
+ * and re-scheduling itself if applicable).
+ *
+ * @param cls the `struct Queue` to process transmissions for
+ */
+static void
+transmit_on_queue (void *cls);
+
+
+/**
+ * Check if the communicator has another queue with higher prio ready for sending.
+ */
+static unsigned int
+check_for_queue_with_higher_prio (struct Queue *queue, struct Queue *queue_head)
+{
+  for (struct Queue *s = queue_head; NULL != s;
+       s = s->next_client)
+  {
+    if (s->tc->details.communicator.address_prefix !=
+        queue->tc->details.communicator.address_prefix)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "queue address %s qid %u compare with queue: address %s qid %u\n",
+                  queue->address,
+                  queue->qid,
+                  s->address,
+                  s->qid);
+      if ((s->priority > queue->priority) && (0 < s->q_capacity) &&
+          (QUEUE_LENGTH_LIMIT > s->queue_length) )
+        return GNUNET_YES;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Lower prio\n");
+    }
+  }
+  return GNUNET_NO;
+}
+
+
+/**
+ * Called whenever something changed that might effect when we
+ * try to do the next transmission on @a queue using #transmit_on_queue().
+ *
+ * @param queue the queue to do scheduling for
+ * @param p task priority to use, if @a queue is scheduled
+ */
+static void
+schedule_transmit_on_queue (struct GNUNET_TIME_Relative delay,
+                            struct Queue *queue,
+                            enum GNUNET_SCHEDULER_Priority p)
+{
+  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
+
+  if (queue->validated_until.abs_value_us < now.abs_value_us)
+    return;
+  if (check_for_queue_with_higher_prio (queue,
+                                        queue->tc->details.communicator.
+                                        queue_head))
+    return;
+
+  if (queue->tc->details.communicator.total_queue_length >=
+      COMMUNICATOR_TOTAL_QUEUE_LIMIT)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmission on queue %s (QID %u) throttled due to communicator queue limit\n",
+                queue->address,
+                queue->qid);
+    GNUNET_STATISTICS_update (
+      GST_stats,
+      "# Transmission throttled due to communicator queue limit",
+      1,
+      GNUNET_NO);
+    queue->idle = GNUNET_NO;
+    return;
+  }
+  if (queue->queue_length >= QUEUE_LENGTH_LIMIT)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmission on queue %s (QID %u) throttled due to communicator queue length limit\n",
+                queue->address,
+                queue->qid);
+    GNUNET_STATISTICS_update (GST_stats,
+                              "# Transmission throttled due to queue queue limit",
+                              1,
+                              GNUNET_NO);
+    queue->idle = GNUNET_NO;
+    return;
+  }
+  if (0 == queue->q_capacity)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmission on queue %s (QID %u) throttled due to communicator message  has capacity %"
+                PRIu64 ".\n",
+                queue->address,
+                queue->qid,
+                queue->q_capacity);
+    GNUNET_STATISTICS_update (GST_stats,
+                              "# Transmission throttled due to message queue capacity",
+                              1,
+                              GNUNET_NO);
+    queue->idle = GNUNET_NO;
+    return;
+  }
+  /* queue might indeed be ready, schedule it */
+  if (NULL != queue->transmit_task)
+    GNUNET_SCHEDULER_cancel (queue->transmit_task);
+  queue->transmit_task =
+    GNUNET_SCHEDULER_add_delayed_with_priority (delay, p, &transmit_on_queue,
+                                                queue);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Considering transmission on queue `%s' QID %llu to %s\n",
+              queue->address,
+              (unsigned long long) queue->qid,
+              GNUNET_i2s (&queue->neighbour->pid));
+}
+
+
+/**
+ * Task run to check whether the hops of the @a cls still
+ * are validated, or if we need to core about disconnection.
+ *
+ * @param cls a `struct VirtualLink`
+ */
+static void
+check_link_down (void *cls)
+{
+  struct VirtualLink *vl = cls;
+  struct DistanceVector *dv = vl->dv;
+  struct Neighbour *n = vl->n;
+  struct GNUNET_TIME_Absolute dvh_timeout;
+  struct GNUNET_TIME_Absolute q_timeout;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Checking if link is down\n");
+  vl->visibility_task = NULL;
+  dvh_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
+  if (NULL != dv)
+  {
+    for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
+         pos = pos->next_dv)
+      dvh_timeout = GNUNET_TIME_absolute_max (dvh_timeout,
+                                              pos->path_valid_until);
+    if (0 == GNUNET_TIME_absolute_get_remaining (dvh_timeout).rel_value_us)
+    {
+      vl->dv->vl = NULL;
+      vl->dv = NULL;
+    }
+  }
+  q_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
+  for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
+    q_timeout = GNUNET_TIME_absolute_max (q_timeout, q->validated_until);
+  if (0 == GNUNET_TIME_absolute_get_remaining (q_timeout).rel_value_us)
+  {
+    vl->n->vl = NULL;
+    vl->n = NULL;
+  }
+  if ((NULL == vl->n) && (NULL == vl->dv))
+  {
+    cores_send_disconnect_info (&vl->target);
+    free_virtual_link (vl);
+    return;
+  }
+  vl->visibility_task =
+    GNUNET_SCHEDULER_add_at (GNUNET_TIME_absolute_max (q_timeout, dvh_timeout),
+                             &check_link_down,
+                             vl);
+}
+
+
+/**
+ * Free @a queue.
+ *
+ * @param queue the queue to free
+ */
+static void
+free_queue (struct Queue *queue)
+{
+  struct Neighbour *neighbour = queue->neighbour;
+  struct TransportClient *tc = queue->tc;
+  struct MonitorEvent me = { .cs = GNUNET_TRANSPORT_CS_DOWN,
+                             .rtt = GNUNET_TIME_UNIT_FOREVER_REL };
+  struct QueueEntry *qe;
+  int maxxed;
+  struct PendingAcknowledgement *pa;
+  struct VirtualLink *vl;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Cleaning up queue %u\n", queue->qid);
+  if (NULL != queue->mo)
+  {
+    GNUNET_PEERSTORE_monitor_stop (queue->mo);
+    queue->mo = NULL;
+  }
+  if (NULL != queue->transmit_task)
+  {
+    GNUNET_SCHEDULER_cancel (queue->transmit_task);
+    queue->transmit_task = NULL;
+  }
+  while (NULL != (pa = queue->pa_head))
+  {
+    GNUNET_CONTAINER_MDLL_remove (queue, queue->pa_head, queue->pa_tail, pa);
+    pa->queue = NULL;
+  }
+
+  GNUNET_CONTAINER_MDLL_remove (neighbour,
+                                neighbour->queue_head,
+                                neighbour->queue_tail,
+                                queue);
+  GNUNET_CONTAINER_MDLL_remove (client,
+                                tc->details.communicator.queue_head,
+                                tc->details.communicator.queue_tail,
+                                queue);
+  maxxed = (COMMUNICATOR_TOTAL_QUEUE_LIMIT <=
+            tc->details.communicator.total_queue_length);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Cleaning up queue with length %u\n",
+              queue->queue_length);
+  while (NULL != (qe = queue->queue_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (queue->queue_head, queue->queue_tail, qe);
+    queue->queue_length--;
+    tc->details.communicator.total_queue_length--;
+    if (NULL != qe->pm)
+    {
+      GNUNET_assert (qe == qe->pm->qe);
+      qe->pm->qe = NULL;
+    }
+    GNUNET_free (qe);
+  }
+  GNUNET_assert (0 == queue->queue_length);
+  if ((maxxed) && (COMMUNICATOR_TOTAL_QUEUE_LIMIT >
+                   tc->details.communicator.total_queue_length))
+  {
+    /* Communicator dropped below threshold, resume all _other_ queues */
+    GNUNET_STATISTICS_update (
+      GST_stats,
+      "# Transmission throttled due to communicator queue limit",
+      -1,
+      GNUNET_NO);
+    for (struct Queue *s = tc->details.communicator.queue_head; NULL != s;
+         s = s->next_client)
+      schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
+                                  s,
+                                  GNUNET_SCHEDULER_PRIORITY_DEFAULT);
+  }
+  notify_monitors (&neighbour->pid, queue->address, queue->nt, &me);
+  GNUNET_free (queue);
+
+  vl = lookup_virtual_link (&neighbour->pid);
+  if ((NULL != vl) && (neighbour == vl->n))
+  {
+    GNUNET_SCHEDULER_cancel (vl->visibility_task);
+    check_link_down (vl);
+  }
+  if (NULL == neighbour->queue_head)
+  {
+    free_neighbour (neighbour);
+  }
+}
+
+
+/**
+ * Free @a ale
+ *
+ * @param ale address list entry to free
+ */
+static void
+free_address_list_entry (struct AddressListEntry *ale)
+{
+  struct TransportClient *tc = ale->tc;
+
+  GNUNET_CONTAINER_DLL_remove (tc->details.communicator.addr_head,
+                               tc->details.communicator.addr_tail,
+                               ale);
+  if (NULL != ale->sc)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "store cancel\n");
+    GNUNET_PEERSTORE_store_cancel (ale->sc);
+    ale->sc = NULL;
+  }
+  if (NULL != ale->st)
+  {
+    GNUNET_SCHEDULER_cancel (ale->st);
+    ale->st = NULL;
+  }
+  if (NULL != ale->signed_address)
+    GNUNET_free (ale->signed_address);
+  GNUNET_free (ale);
+}
+
+
+/**
+ * Stop the peer request in @a value.
+ *
+ * @param cls a `struct TransportClient` that no longer makes the request
+ * @param pid the peer's identity
+ * @param value a `struct PeerRequest`
+ * @return #GNUNET_YES (always)
+ */
+static int
+stop_peer_request (void *cls,
+                   const struct GNUNET_PeerIdentity *pid,
+                   void *value)
+{
+  struct TransportClient *tc = cls;
+  struct PeerRequest *pr = value;
+
+  if (NULL != pr->nc)
+    GNUNET_PEERSTORE_monitor_stop (pr->nc);
+  pr->nc = NULL;
+  GNUNET_assert (
+    GNUNET_YES ==
+    GNUNET_CONTAINER_multipeermap_remove (tc->details.application.requests,
+                                          pid,
+                                          pr));
+  GNUNET_free (pr);
+
+  return GNUNET_OK;
+}
+
+
+static void
+do_shutdown (void *cls);
+
+/**
+ * Called whenever a client is disconnected.  Frees our
+ * resources associated with that client.
+ *
+ * @param cls closure, NULL
+ * @param client identification of the client
+ * @param app_ctx our `struct TransportClient`
+ */
+static void
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *app_ctx)
+{
+  struct TransportClient *tc = app_ctx;
+
+  (void) cls;
+  (void) client;
+  GNUNET_CONTAINER_DLL_remove (clients_head, clients_tail, tc);
+  switch (tc->type)
+  {
+  case CT_NONE:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Unknown Client %p disconnected, cleaning up.\n",
+                tc);
+    break;
+
+  case CT_CORE: {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "CORE Client %p disconnected, cleaning up.\n",
+                  tc);
+
+      struct PendingMessage *pm;
+
+      while (NULL != (pm = tc->details.core.pending_msg_head))
+      {
+        GNUNET_CONTAINER_MDLL_remove (client,
+                                      tc->details.core.pending_msg_head,
+                                      tc->details.core.pending_msg_tail,
+                                      pm);
+        pm->client = NULL;
+      }
+    }
+    break;
+
+  case CT_MONITOR:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "MONITOR Client %p disconnected, cleaning up.\n",
+                tc);
+
+    break;
+
+  case CT_COMMUNICATOR: {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "COMMUNICATOR Client %p disconnected, cleaning up.\n",
+                  tc);
+
+      struct Queue *q;
+      struct AddressListEntry *ale;
+
+      if (NULL != tc->details.communicator.free_queue_entry_task)
+        GNUNET_SCHEDULER_cancel (
+          tc->details.communicator.free_queue_entry_task);
+      while (NULL != (q = tc->details.communicator.queue_head))
+        free_queue (q);
+      while (NULL != (ale = tc->details.communicator.addr_head))
+        free_address_list_entry (ale);
+      GNUNET_free (tc->details.communicator.address_prefix);
+    }
+    break;
+
+  case CT_APPLICATION:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "APPLICATION Client %p disconnected, cleaning up.\n",
+                tc);
+
+    GNUNET_CONTAINER_multipeermap_iterate (tc->details.application.requests,
+                                           &stop_peer_request,
+                                           tc);
+    GNUNET_CONTAINER_multipeermap_destroy (tc->details.application.requests);
+    break;
+  }
+  GNUNET_free (tc);
+  if ((GNUNET_YES == in_shutdown) && (NULL == clients_head))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Our last client disconnected\n");
+    do_shutdown (cls);
+  }
+}
+
+
+/**
+ * Iterator telling new CORE client about all existing
+ * connections to peers.
+ *
+ * @param cls the new `struct TransportClient`
+ * @param pid a connected peer
+ * @param value the `struct Neighbour` with more information
+ * @return #GNUNET_OK (continue to iterate)
+ */
+static int
+notify_client_connect_info (void *cls,
+                            const struct GNUNET_PeerIdentity *pid,
+                            void *value)
+{
+  struct TransportClient *tc = cls;
+  struct VirtualLink *vl = value;
+
+  if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
+    return GNUNET_OK;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Telling new CORE client about existing connection to %s\n",
+              GNUNET_i2s (pid));
+  core_send_connect_info (tc, pid);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Send ACK to communicator (if requested) and free @a cmc.
+ *
+ * @param cmc context for which we are done handling the message
+ */
+static void
+finish_cmc_handling_with_continue (struct CommunicatorMessageContext *cmc,
+                                   unsigned
+                                   int free_cmc);
+
+static enum GNUNET_GenericReturnValue
+resume_communicators (void *cls,
+                      const struct GNUNET_PeerIdentity *pid,
+                      void *value)
+{
+  struct VirtualLink *vl = value;
+  struct CommunicatorMessageContext *cmc;
+
+  /* resume communicators */
+  while (NULL != (cmc = vl->cmc_tail))
+  {
+    GNUNET_CONTAINER_DLL_remove (vl->cmc_head, vl->cmc_tail, cmc);
+    if (GNUNET_NO == cmc->continue_send)
+      finish_cmc_handling_with_continue (cmc, GNUNET_YES);
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Initialize a "CORE" client.  We got a start message from this
+ * client, so add it to the list of clients for broadcasting of
+ * inbound messages.
+ *
+ * @param cls the client
+ * @param start the start message that was sent
+ */
+static void
+handle_client_start (void *cls, const struct StartMessage *start)
+{
+  struct TransportClient *tc = cls;
+  uint32_t options;
+
+  options = ntohl (start->options);
+  if ((0 != (1 & options)) &&
+      (0 != GNUNET_memcmp (&start->self, &GST_my_identity)))
+  {
+    /* client thinks this is a different peer, reject */
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (tc->client);
+    return;
+  }
+  if (CT_NONE != tc->type)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (tc->client);
+    return;
+  }
+  tc->type = CT_CORE;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "New CORE client with PID %s registered\n",
+              GNUNET_i2s (&start->self));
+  GNUNET_CONTAINER_multipeermap_iterate (links,
+                                         &notify_client_connect_info,
+                                         tc);
+  GNUNET_CONTAINER_multipeermap_iterate (links,
+                                         &resume_communicators,
+                                         NULL);
+  GNUNET_SERVICE_client_continue (tc->client);
+}
+
+
+/**
+ * Client asked for transmission to a peer.  Process the request.
+ *
+ * @param cls the client
+ * @param obm the send message that was sent
+ */
+static int
+check_client_send (void *cls, const struct OutboundMessage *obm)
+{
+  struct TransportClient *tc = cls;
+  uint16_t size;
+  const struct GNUNET_MessageHeader *obmm;
+
+  if (CT_CORE != tc->type)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  size = ntohs (obm->header.size) - sizeof(struct OutboundMessage);
+  if (size < sizeof(struct GNUNET_MessageHeader))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  obmm = (const struct GNUNET_MessageHeader *) &obm[1];
+  if (size != ntohs (obmm->size))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Send a response to the @a pm that we have processed a "send"
+ * request.  Sends a confirmation to the "core" client responsible for
+ * the original request and free's @a pm.
+ *
+ * @param pm handle to the original pending message
+ */
+static void
+client_send_response (struct PendingMessage *pm)
+{
+  struct TransportClient *tc = pm->client;
+  struct VirtualLink *vl = pm->vl;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "client send response\n");
+  if (NULL != tc)
+  {
+    struct GNUNET_MQ_Envelope *env;
+    struct SendOkMessage *so_msg;
+
+    env = GNUNET_MQ_msg (so_msg, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK);
+    so_msg->peer = vl->target;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Confirming transmission of <%" PRIu64 "> to %s\n",
+                pm->logging_uuid,
+                GNUNET_i2s (&vl->target));
+    GNUNET_MQ_send (tc->mq, env);
+  }
+  free_pending_message (pm);
+}
+
+
+/**
+ * Pick @a hops_array_length random DV paths satisfying @a options
+ *
+ * @param dv data structure to pick paths from
+ * @param options constraints to satisfy
+ * @param[out] hops_array set to the result
+ * @param hops_array_length length of the @a hops_array
+ * @return number of entries set in @a hops_array
+ */
+static unsigned int
+pick_random_dv_hops (const struct DistanceVector *dv,
+                     enum RouteMessageOptions options,
+                     struct DistanceVectorHop **hops_array,
+                     unsigned int hops_array_length)
+{
+  uint64_t choices[hops_array_length];
+  uint64_t num_dv;
+  unsigned int dv_count;
+
+  /* Pick random vectors, but weighted by distance, giving more weight
+     to shorter vectors */
+  num_dv = 0;
+  dv_count = 0;
+  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
+       pos = pos->next_dv)
+  {
+    if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) &&
+        (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until)
+         .rel_value_us == 0))
+      continue;   /* pos unconfirmed and confirmed required */
+    num_dv += MAX_DV_HOPS_ALLOWED - pos->distance;
+    dv_count++;
+  }
+  if (0 == dv_count)
+    return 0;
+  if (dv_count <= hops_array_length)
+  {
+    dv_count = 0;
+    for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
+         pos = pos->next_dv)
+      hops_array[dv_count++] = pos;
+    return dv_count;
+  }
+  for (unsigned int i = 0; i < hops_array_length; i++)
+  {
+    int ok = GNUNET_NO;
+    while (GNUNET_NO == ok)
+    {
+      choices[i] =
+        GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, num_dv);
+      ok = GNUNET_YES;
+      for (unsigned int j = 0; j < i; j++)
+        if (choices[i] == choices[j])
+        {
+          ok = GNUNET_NO;
+          break;
+        }
+    }
+  }
+  dv_count = 0;
+  num_dv = 0;
+  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
+       pos = pos->next_dv)
+  {
+    uint32_t delta = MAX_DV_HOPS_ALLOWED - pos->distance;
+
+    if ((0 == (options & RMO_UNCONFIRMED_ALLOWED)) &&
+        (GNUNET_TIME_absolute_get_remaining (pos->path_valid_until)
+         .rel_value_us == 0))
+      continue;   /* pos unconfirmed and confirmed required */
+    for (unsigned int i = 0; i < hops_array_length; i++)
+      if ((num_dv <= choices[i]) && (num_dv + delta > choices[i]))
+        hops_array[dv_count++] = pos;
+    num_dv += delta;
+  }
+  return dv_count;
+}
+
+
+/**
+ * Communicator started.  Test message is well-formed.
+ *
+ * @param cls the client
+ * @param cam the send message that was sent
+ */
+static int
+check_communicator_available (
+  void *cls,
+  const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam)
+{
+  struct TransportClient *tc = cls;
+  uint16_t size;
+
+  if (CT_NONE != tc->type)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  tc->type = CT_COMMUNICATOR;
+  size = ntohs (cam->header.size) - sizeof(*cam);
+  if (0 == size)
+    return GNUNET_OK; /* receive-only communicator */
+  GNUNET_MQ_check_zero_termination (cam);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Send ACK to communicator (if requested) and free @a cmc.
+ *
+ * @param cmc context for which we are done handling the message
+ */
+static void
+finish_cmc_handling_with_continue (struct CommunicatorMessageContext *cmc,
+                                   unsigned
+                                   int free_cmc)
+{
+  if (0 != ntohl (cmc->im.fc_on))
+  {
+    /* send ACK when done to communicator for flow control! */
+    struct GNUNET_MQ_Envelope *env;
+    struct GNUNET_TRANSPORT_IncomingMessageAck *ack;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Acknowledge message with flow control id %" PRIu64 "\n",
+                cmc->im.fc_id);
+    env = GNUNET_MQ_msg (ack, GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK);
+    ack->reserved = htonl (0);
+    ack->fc_id = cmc->im.fc_id;
+    ack->sender = cmc->im.neighbour_sender;
+    GNUNET_MQ_send (cmc->tc->mq, env);
+  }
+
+  GNUNET_SERVICE_client_continue (cmc->tc->client);
+
+  if (GNUNET_YES == free_cmc)
+  {
+    GNUNET_free (cmc);
+  }
+}
+
+
+static void
+finish_cmc_handling (struct CommunicatorMessageContext *cmc)
+{
+  finish_cmc_handling_with_continue (cmc, GNUNET_YES);
+}
+
+
+/**
+ * Client confirms that it is done handling message(s) to a particular
+ * peer. We may now provide more messages to CORE for this peer.
+ *
+ * Notifies the respective queues that more messages can now be received.
+ *
+ * @param cls the client
+ * @param rom the message that was sent
+ */
+static void
+handle_client_recv_ok (void *cls, const struct RecvOkMessage *rom)
+{
+  struct TransportClient *tc = cls;
+  struct VirtualLink *vl;
+  uint32_t delta;
+  struct CommunicatorMessageContext *cmc;
+
+  if (CT_CORE != tc->type)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (tc->client);
+    return;
+  }
+  vl = lookup_virtual_link (&rom->peer);
+  if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
+  {
+    GNUNET_STATISTICS_update (GST_stats,
+                              "# RECV_OK dropped: virtual link unknown",
+                              1,
+                              GNUNET_NO);
+    GNUNET_SERVICE_client_continue (tc->client);
+    return;
+  }
+  delta = ntohl (rom->increase_window_delta);
+  vl->core_recv_window += delta;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "CORE ack receiving message, increased CORE recv window to %d\n",
+              vl->core_recv_window);
+  GNUNET_SERVICE_client_continue (tc->client);
+  if (vl->core_recv_window <= 0)
+    return;
+  /* resume communicators */
+  while (NULL != (cmc = vl->cmc_tail))
+  {
+    GNUNET_CONTAINER_DLL_remove (vl->cmc_head, vl->cmc_tail, cmc);
+    if (GNUNET_NO == cmc->continue_send)
+      finish_cmc_handling_with_continue (cmc, GNUNET_YES);
+  }
+}
+
+
+/**
+ * Communicator started.  Process the request.
+ *
+ * @param cls the client
+ * @param cam the send message that was sent
+ */
+static void
+handle_communicator_available (
+  void *cls,
+  const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam)
+{
+  struct TransportClient *tc = cls;
+  uint16_t size;
+
+  size = ntohs (cam->header.size) - sizeof(*cam);
+  if (0 == size)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Receive-only communicator connected\n");
+    return;   /* receive-only communicator */
+  }
+  tc->details.communicator.address_prefix =
+    GNUNET_strdup ((const char *) &cam[1]);
+  tc->details.communicator.cc =
+    (enum GNUNET_TRANSPORT_CommunicatorCharacteristics) ntohl (cam->cc);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Communicator with prefix `%s' connected\n",
+              tc->details.communicator.address_prefix);
+  GNUNET_SERVICE_client_continue (tc->client);
+}
+
+
+/**
+ * Communicator requests backchannel transmission.  Check the request.
+ *
+ * @param cls the client
+ * @param cb the send message that was sent
+ * @return #GNUNET_OK if message is well-formed
+ */
+static int
+check_communicator_backchannel (
+  void *cls,
+  const struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb)
+{
+  const struct GNUNET_MessageHeader *inbox;
+  const char *is;
+  uint16_t msize;
+  uint16_t isize;
+
+  (void) cls;
+  msize = ntohs (cb->header.size) - sizeof(*cb);
+  inbox = (const struct GNUNET_MessageHeader *) &cb[1];
+  isize = ntohs (inbox->size);
+  if (isize >= msize)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  is = (const char *) inbox;
+  is += isize;
+  msize -= isize;
+  GNUNET_assert (0 < msize);
+  if ('\0' != is[msize - 1])
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Sign ephemeral keys in our @a dv are current.
+ *
+ * @param[in,out] dv virtual link to update ephemeral for
+ */
+static void
+sign_ephemeral (struct DistanceVector *dv)
+{
+  struct EphemeralConfirmationPS ec;
+
+  dv->monotime = GNUNET_TIME_absolute_get_monotonic (GST_cfg);
+  dv->ephemeral_validity =
+    GNUNET_TIME_absolute_add (dv->monotime, EPHEMERAL_VALIDITY);
+  ec.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL);
+  ec.target = dv->target;
+  ec.ephemeral_key = dv->ephemeral_key;
+  ec.sender_monotonic_time = GNUNET_TIME_absolute_hton (dv->monotime);
+  ec.purpose.size = htonl (sizeof(ec));
+  GNUNET_CRYPTO_eddsa_sign (GST_my_private_key,
+                            &ec,
+                            &dv->sender_sig);
+}
+
+
+static void
+free_queue_entry (struct QueueEntry *qe,
+                  struct TransportClient *tc);
+
+
+static void
+free_timedout_queue_entry (void *cls)
+{
+  struct TransportClient *tc = cls;
+  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "freeing timedout queue entries\n");
+
+  tc->details.communicator.free_queue_entry_task = NULL;
+  for (struct Queue *queue = tc->details.communicator.queue_head; NULL != queue;
+       queue = queue->next_client)
+  {
+    struct QueueEntry *qep = queue->queue_head;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "checking QID %u for timedout queue entries\n",
+                queue->qid);
+    while (NULL != qep)
+    {
+      struct QueueEntry *pos = qep;
+
+      qep = qep->next;
+      struct GNUNET_TIME_Relative diff = GNUNET_TIME_absolute_get_difference (
+        pos->creation_timestamp, now);
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "diff to now %s \n",
+                  GNUNET_TIME_relative2s (diff, GNUNET_NO));
+      if (GNUNET_TIME_relative_cmp (QUEUE_ENTRY_TIMEOUT, <, diff))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Freeing timed out QueueEntry with MID %" PRIu64
+                    " and QID %u\n",
+                    pos->mid,
+                    queue->qid);
+        free_queue_entry (pos, tc);
+      }
+    }
+  }
+}
+
+
+/**
+ * Send the message @a payload on @a queue.
+ *
+ * @param queue the queue to use for transmission
+ * @param pm pending message to update once transmission is done, may be NULL!
+ * @param payload the payload to send (encapsulated in a
+ *        #GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG).
+ * @param payload_size number of bytes in @a payload
+ */
+static void
+queue_send_msg (struct Queue *queue,
+                struct PendingMessage *pm,
+                const void *payload,
+                size_t payload_size)
+{
+  struct Neighbour *n = queue->neighbour;
+  struct GNUNET_TRANSPORT_SendMessageTo *smt;
+  struct GNUNET_MQ_Envelope *env;
+  struct PendingAcknowledgement *pa;
+
+  GNUNET_log (
+    GNUNET_ERROR_TYPE_DEBUG,
+    "Queueing %u bytes of payload for transmission <%" PRIu64
+    "> on queue %llu to %s\n",
+    (unsigned int) payload_size,
+    (NULL == pm) ? 0 : pm->logging_uuid,
+    (unsigned long long) queue->qid,
+    GNUNET_i2s (&queue->neighbour->pid));
+  env = GNUNET_MQ_msg_extra (smt,
+                             payload_size,
+                             GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG);
+  smt->qid = htonl (queue->qid);
+  smt->mid = GNUNET_htonll (queue->mid_gen);
+  smt->receiver = n->pid;
+  memcpy (&smt[1], payload, payload_size);
+  {
+    /* Pass the env to the communicator of queue for transmission. */
+    struct QueueEntry *qe;
+
+    qe = GNUNET_new (struct QueueEntry);
+    qe->creation_timestamp = GNUNET_TIME_absolute_get ();
+    qe->mid = queue->mid_gen;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Create QueueEntry with MID %" PRIu64
+                " and QID %u and prefix %s\n",
+                qe->mid,
+                queue->qid,
+                queue->tc->details.communicator.address_prefix);
+    queue->mid_gen++;
+    qe->queue = queue;
+    if (NULL != pm)
+    {
+      qe->pm = pm;
+      // TODO Why do we have a retransmission. When we know, make decision if we still want this.
+      // GNUNET_assert (NULL == pm->qe);
+      if (NULL != pm->qe)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Retransmitting message <%" PRIu64
+                    "> remove pm from qe with MID: %llu \n",
+                    pm->logging_uuid,
+                    (unsigned long long) pm->qe->mid);
+        pm->qe->pm = NULL;
+      }
+      pm->qe = qe;
+    }
+    GNUNET_assert (CT_COMMUNICATOR == queue->tc->type);
+    if (0 == queue->q_capacity)
+    {
+      // Messages without FC or fragments can get here.
+      if (NULL != pm)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Message %" PRIu64
+                    " (pm type %u) was not send because queue has no capacity.\n",
+                    pm->logging_uuid,
+                    pm->pmt);
+        pm->qe = NULL;
+      }
+      GNUNET_free (env);
+      GNUNET_free (qe);
+      return;
+    }
+    GNUNET_CONTAINER_DLL_insert (queue->queue_head, queue->queue_tail, qe);
+    queue->queue_length++;
+    queue->tc->details.communicator.total_queue_length++;
+    if (GNUNET_NO == queue->unlimited_length)
+      queue->q_capacity--;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Queue %s with qid %u has capacity %" PRIu64 "\n",
+                queue->address,
+                queue->qid,
+                queue->q_capacity);
+    if (COMMUNICATOR_TOTAL_QUEUE_LIMIT ==
+        queue->tc->details.communicator.total_queue_length)
+      queue->idle = GNUNET_NO;
+    if (QUEUE_LENGTH_LIMIT == queue->queue_length)
+      queue->idle = GNUNET_NO;
+    if (0 == queue->q_capacity)
+      queue->idle = GNUNET_NO;
+
+    if (GNUNET_NO == queue->idle)
+    {
+      struct TransportClient *tc = queue->tc;
+
+      if (NULL == tc->details.communicator.free_queue_entry_task)
+        tc->details.communicator.free_queue_entry_task =
+          GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                        &
+                                        free_timedout_queue_entry,
+                                        tc);
+    }
+    if (NULL != pm && NULL != (pa = pm->pa_head))
+    {
+      while (pm != pa->pm)
+        pa = pa->next_pa;
+      pa->num_send++;
+    }
+    // GNUNET_CONTAINER_multiuuidmap_get (pending_acks, &ack[i].ack_uuid.value);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending message MID %" PRIu64
+                " of type %u (%u) and size %lu with MQ %p queue %s (QID %u) pending %"
+                PRIu64 "\n",
+                GNUNET_ntohll (smt->mid),
+                ntohs (((const struct GNUNET_MessageHeader *) payload)->type),
+                ntohs (smt->header.size),
+                (unsigned long) payload_size,
+                queue->tc->mq,
+                queue->address,
+                queue->qid,
+                (NULL == pm) ? 0 : pm->logging_uuid);
+    GNUNET_MQ_send (queue->tc->mq, env);
+  }
+}
+
+
+/**
+ * Pick a queue of @a n under constraints @a options and schedule
+ * transmission of @a hdr.
+ *
+ * @param n neighbour to send to
+ * @param hdr message to send as payload
+ * @param options whether queues must be confirmed or not,
+ *        and whether we may pick multiple (2) queues
+ * @return expected RTT for transmission, #GNUNET_TIME_UNIT_FOREVER_REL if sending failed
+ */
+static struct GNUNET_TIME_Relative
+route_via_neighbour (const struct Neighbour *n,
+                     const struct GNUNET_MessageHeader *hdr,
+                     enum RouteMessageOptions options)
+{
+  struct GNUNET_TIME_Absolute now;
+  unsigned int candidates;
+  unsigned int sel1;
+  unsigned int sel2;
+  struct GNUNET_TIME_Relative rtt;
+
+  /* Pick one or two 'random' queues from n (under constraints of options) */
+  now = GNUNET_TIME_absolute_get ();
+  /* FIXME-OPTIMIZE: give queues 'weights' and pick proportional to
+     weight in the future; weight could be assigned by observed
+     bandwidth (note: not sure if we should do this for this type
+     of control traffic though). */
+  candidates = 0;
+  for (struct Queue *pos = n->queue_head; NULL != pos;
+       pos = pos->next_neighbour)
+  {
+    if ((0 != (options & RMO_UNCONFIRMED_ALLOWED)) ||
+        (pos->validated_until.abs_value_us > now.abs_value_us))
+      candidates++;
+  }
+  if (0 == candidates)
+  {
+    /* This can happen rarely if the last confirmed queue timed
+       out just as we were beginning to process this message. */
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Could not route message of type %u to %s: no valid queue\n",
+                ntohs (hdr->type),
+                GNUNET_i2s (&n->pid));
+    GNUNET_STATISTICS_update (GST_stats,
+                              "# route selection failed (all no valid queue)",
+                              1,
+                              GNUNET_NO);
+    return GNUNET_TIME_UNIT_FOREVER_REL;
+  }
+
+  rtt = GNUNET_TIME_UNIT_FOREVER_REL;
+  sel1 = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, candidates);
+  if (0 == (options & RMO_REDUNDANT))
+    sel2 = candidates; /* picks none! */
+  else
+    sel2 = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, candidates);
+  candidates = 0;
+  for (struct Queue *pos = n->queue_head; NULL != pos;
+       pos = pos->next_neighbour)
+  {
+    if ((0 != (options & RMO_UNCONFIRMED_ALLOWED)) ||
+        (pos->validated_until.abs_value_us > now.abs_value_us))
+    {
+      if ((sel1 == candidates) || (sel2 == candidates))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Routing message of type %u to %s using %s (#%u)\n",
+                    ntohs (hdr->type),
+                    GNUNET_i2s (&n->pid),
+                    pos->address,
+                    (sel1 == candidates) ? 1 : 2);
+        rtt = GNUNET_TIME_relative_min (rtt, pos->pd.aged_rtt);
+        queue_send_msg (pos, NULL, hdr, ntohs (hdr->size));
+      }
+      candidates++;
+    }
+  }
+  return rtt;
+}
+
+
+/**
+ * Structure of the key material used to encrypt backchannel messages.
+ */
+struct DVKeyState
+{
+  /**
+   * State of our block cipher.
+   */
+  gcry_cipher_hd_t cipher;
+
+  /**
+   * Actual key material.
+   */
+  struct
+  {
+    /**
+     * Key used for HMAC calculations (via #GNUNET_CRYPTO_hmac()).
+     */
+    struct GNUNET_CRYPTO_AuthKey hmac_key;
+
+    /**
+     * Symmetric key to use for encryption.
+     */
+    char aes_key[256 / 8];
+
+    /**
+     * Counter value to use during setup.
+     */
+    char aes_ctr[128 / 8];
+  } material;
+};
+
+
+/**
+ * Given the key material in @a km and the initialization vector
+ * @a iv, setup the key material for the backchannel in @a key.
+ *
+ * @param km raw master secret
+ * @param iv initialization vector
+ * @param[out] key symmetric cipher and HMAC state to generate
+ */
+static void
+dv_setup_key_state_from_km (const struct GNUNET_HashCode *km,
+                            const struct GNUNET_ShortHashCode *iv,
+                            struct DVKeyState *key)
+{
+  /* must match what we defive from decapsulated key */
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CRYPTO_kdf (&key->material,
+                                    sizeof(key->material),
+                                    "transport-backchannel-key",
+                                    strlen ("transport-backchannel-key"),
+                                    km,
+                                    sizeof(*km),
+                                    iv,
+                                    sizeof(*iv),
+                                    NULL));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Deriving backchannel key based on KM %s and IV %s\n",
+              GNUNET_h2s (km),
+              GNUNET_sh2s (iv));
+  GNUNET_assert (0 == gcry_cipher_open (&key->cipher,
+                                        GCRY_CIPHER_AES256 /* low level: go for speed */,
+                                        GCRY_CIPHER_MODE_CTR,
+                                        0 /* flags */));
+  GNUNET_assert (0 == gcry_cipher_setkey (key->cipher,
+                                          &key->material.aes_key,
+                                          sizeof(key->material.aes_key)));
+  gcry_cipher_setctr (key->cipher,
+                      &key->material.aes_ctr,
+                      sizeof(key->material.aes_ctr));
+}
+
+
+/**
+ * Do HMAC calculation for backchannel messages over @a data using key
+ * material from @a key.
+ *
+ * @param key key material (from DH)
+ * @param[out] hmac set to the HMAC
+ * @param data data to perform HMAC calculation over
+ * @param data_size number of bytes in @a data
+ */
+static void
+dv_hmac (const struct DVKeyState *key,
+         struct GNUNET_HashCode *hmac,
+         const void *data,
+         size_t data_size)
+{
+  GNUNET_CRYPTO_hmac (&key->material.hmac_key, data, data_size, hmac);
+}
+
+
+/**
+ * Perform backchannel encryption using symmetric secret in @a key
+ * to encrypt data from @a in to @a dst.
+ *
+ * @param[in,out] key key material to use
+ * @param dst where to write the result
+ * @param in input data to encrypt (plaintext)
+ * @param in_size number of bytes of input in @a in and available at @a dst
+ */
+static void
+dv_encrypt (struct DVKeyState *key, const void *in, void *dst, size_t in_size)
+{
+  GNUNET_assert (0 ==
+                 gcry_cipher_encrypt (key->cipher, dst, in_size, in, in_size));
+}
+
+
+/**
+ * Perform backchannel encryption using symmetric secret in @a key
+ * to encrypt data from @a in to @a dst.
+ *
+ * @param[in,out] key key material to use
+ * @param ciph cipher text to decrypt
+ * @param[out] out output data to generate (plaintext)
+ * @param out_size number of bytes of input in @a ciph and available in @a out
+ * @return GNUNET_OK on success
+ */
+static enum GNUNET_GenericReturnValue
+dv_decrypt (struct DVKeyState *key,
+            void *out,
+            const void *ciph,
+            size_t out_size)
+{
+  return (0 ==
+          gcry_cipher_decrypt (key->cipher,
+                               out, out_size,
+                               ciph, out_size)) ? GNUNET_OK : GNUNET_SYSERR;
+}
+
+
+/**
+ * Clean up key material in @a key.
+ *
+ * @param key key material to clean up (memory must not be free'd!)
+ */
+static void
+dv_key_clean (struct DVKeyState *key)
+{
+  gcry_cipher_close (key->cipher);
+  GNUNET_CRYPTO_zero_keys (&key->material, sizeof(key->material));
+}
+
+
+/**
+ * Function to call to further operate on the now DV encapsulated
+ * message @a hdr, forwarding it via @a next_hop under respect of
+ * @a options.
+ *
+ * @param cls closure
+ * @param next_hop next hop of the DV path
+ * @param hdr encapsulated message, technically a `struct TransportDFBoxMessage`
+ * @param options options of the original message
+ */
+typedef void (*DVMessageHandler) (void *cls,
+                                  struct Neighbour *next_hop,
+                                  const struct GNUNET_MessageHeader *hdr,
+                                  enum RouteMessageOptions options);
+
+/**
+ * Pick a path of @a dv under constraints @a options and schedule
+ * transmission of @a hdr.
+ *
+ * @param target neighbour to ultimately send to
+ * @param num_dvhs length of the @a dvhs array
+ * @param dvhs array of hops to send the message to
+ * @param hdr message to send as payload
+ * @param use function to call with the encapsulated message
+ * @param use_cls closure for @a use
+ * @param options whether path must be confirmed or not, to be passed to @a use
+ * @param without_fc shall this TransportDVBoxMessage be forwarded without flow control.
+ * @return expected RTT for transmission, #GNUNET_TIME_UNIT_FOREVER_REL if sending failed
+ */
+static struct GNUNET_TIME_Relative
+encapsulate_for_dv (struct DistanceVector *dv,
+                    unsigned int num_dvhs,
+                    struct DistanceVectorHop **dvhs,
+                    const struct GNUNET_MessageHeader *hdr,
+                    DVMessageHandler use,
+                    void *use_cls,
+                    enum RouteMessageOptions options,
+                    enum GNUNET_GenericReturnValue without_fc)
+{
+  struct TransportDVBoxMessage box_hdr;
+  struct TransportDVBoxPayloadP payload_hdr;
+  uint16_t enc_body_size = ntohs (hdr->size);
+  char enc[sizeof(struct TransportDVBoxPayloadP) + enc_body_size] GNUNET_ALIGN;
+  struct DVKeyState *key;
+  struct GNUNET_TIME_Relative rtt;
+  struct GNUNET_HashCode km;
+
+  key = GNUNET_new (struct DVKeyState);
+  /* Encrypt payload */
+  box_hdr.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX);
+  box_hdr.total_hops = htons (0);
+  box_hdr.without_fc = htons (without_fc);
+  // update_ephemeral (dv);
+  if (0 ==
+      GNUNET_TIME_absolute_get_remaining (dv->ephemeral_validity).rel_value_us)
+  {
+    GNUNET_CRYPTO_eddsa_kem_encaps (&dv->target.public_key,
+                                    &dv->ephemeral_key,
+                                    &km);
+    dv->km = GNUNET_new (struct GNUNET_HashCode);
+    GNUNET_memcpy (dv->km, &km, sizeof(struct GNUNET_HashCode));
+    sign_ephemeral (dv);
+  }
+  box_hdr.ephemeral_key = dv->ephemeral_key;
+  payload_hdr.sender_sig = dv->sender_sig;
+
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE,
+                              &box_hdr.iv,
+                              sizeof(box_hdr.iv));
+  // We are creating this key, so this must work.
+  // FIXME: Possibly also add return values here. We are processing
+  // Input from other peers...
+  dv_setup_key_state_from_km (dv->km, &box_hdr.iv, key);
+  payload_hdr.sender = GST_my_identity;
+  payload_hdr.monotonic_time = GNUNET_TIME_absolute_hton (dv->monotime);
+  dv_encrypt (key, &payload_hdr, enc, sizeof(payload_hdr));
+  dv_encrypt (key,
+              hdr,
+              &enc[sizeof(struct TransportDVBoxPayloadP)],
+              enc_body_size);
+  dv_hmac (key, &box_hdr.hmac, enc, sizeof(enc));
+  dv_key_clean (key);
+  rtt = GNUNET_TIME_UNIT_FOREVER_REL;
+  /* For each selected path, take the pre-computed header and body
+     and add the path in the middle of the message; then send it. */
+  for (unsigned int i = 0; i < num_dvhs; i++)
+  {
+    struct DistanceVectorHop *dvh = dvhs[i];
+    unsigned int num_hops = dvh->distance + 1;
+    char buf[sizeof(struct TransportDVBoxMessage)
+             + sizeof(struct GNUNET_PeerIdentity) * num_hops
+             + sizeof(struct TransportDVBoxPayloadP)
+             + enc_body_size] GNUNET_ALIGN;
+    struct GNUNET_PeerIdentity *dhops;
+
+    box_hdr.header.size = htons (sizeof(buf));
+    box_hdr.orig_size = htons (sizeof(buf));
+    box_hdr.num_hops = htons (num_hops);
+    memcpy (buf, &box_hdr, sizeof(box_hdr));
+    dhops = (struct GNUNET_PeerIdentity *) &buf[sizeof(box_hdr)];
+    memcpy (dhops,
+            dvh->path,
+            dvh->distance * sizeof(struct GNUNET_PeerIdentity));
+    dhops[dvh->distance] = dv->target;
+    if (GNUNET_EXTRA_LOGGING > 0)
+    {
+      char *path;
+
+      path = GNUNET_strdup (GNUNET_i2s (&GST_my_identity));
+      for (unsigned int j = 0; j < num_hops; j++)
+      {
+        char *tmp;
+
+        GNUNET_asprintf (&tmp, "%s-%s", path, GNUNET_i2s (&dhops[j]));
+        GNUNET_free (path);
+        path = tmp;
+      }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Routing message of type %u to %s using DV (#%u/%u) via %s\n",
+                  ntohs (hdr->type),
+                  GNUNET_i2s (&dv->target),
+                  i + 1,
+                  num_dvhs,
+                  path);
+      GNUNET_free (path);
+    }
+    rtt = GNUNET_TIME_relative_min (rtt, dvh->pd.aged_rtt);
+    memcpy (&dhops[num_hops], enc, sizeof(enc));
+    use (use_cls,
+         dvh->next_hop,
+         (const struct GNUNET_MessageHeader *) buf,
+         options);
+    GNUNET_free (key);
+  }
+  return rtt;
+}
+
+
+/**
+ * Wrapper around #route_via_neighbour() that matches the
+ * #DVMessageHandler structure.
+ *
+ * @param cls unused
+ * @param next_hop where to send next
+ * @param hdr header of the message to send
+ * @param options message options for queue selection
+ */
+static void
+send_dv_to_neighbour (void *cls,
+                      struct Neighbour *next_hop,
+                      const struct GNUNET_MessageHeader *hdr,
+                      enum RouteMessageOptions options)
+{
+  (void) cls;
+  (void) route_via_neighbour (next_hop, hdr, RMO_UNCONFIRMED_ALLOWED);
+}
+
+
+/**
+ * We need to transmit @a hdr to @a target.  If necessary, this may
+ * involve DV routing.  This function routes without applying flow
+ * control or congestion control and should only be used for control
+ * traffic.
+ *
+ * @param target peer to receive @a hdr
+ * @param hdr header of the message to route and #GNUNET_free()
+ * @param options which transmission channels are allowed
+ * @return expected RTT for transmission, #GNUNET_TIME_UNIT_FOREVER_REL if sending failed
+ */
+static struct GNUNET_TIME_Relative
+route_control_message_without_fc (struct VirtualLink *vl,
+// route_control_message_without_fc (const struct GNUNET_PeerIdentity *target,
+                                  const struct GNUNET_MessageHeader *hdr,
+                                  enum RouteMessageOptions options)
+{
+  // struct VirtualLink *vl;
+  struct Neighbour *n;
+  struct DistanceVector *dv;
+  struct GNUNET_TIME_Relative rtt1;
+  struct GNUNET_TIME_Relative rtt2;
+  const struct GNUNET_PeerIdentity *target = &vl->target;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Trying to route message of type %u to %s without fc\n",
+              ntohs (hdr->type),
+              GNUNET_i2s (target));
+
+  // TODO Do this elsewhere. vl should be given as parameter to method.
+  // vl = lookup_virtual_link (target);
+  GNUNET_assert (NULL != vl && GNUNET_YES == vl->confirmed);
+  if (NULL == vl)
+    return GNUNET_TIME_UNIT_FOREVER_REL;
+  n = vl->n;
+  dv = (0 != (options & RMO_DV_ALLOWED)) ? vl->dv : NULL;
+  if (0 == (options & RMO_UNCONFIRMED_ALLOWED))
+  {
+    /* if confirmed is required, and we do not have anything
+       confirmed, drop respective options */
+    if (NULL == n)
+      n = lookup_neighbour (target);
+    if ((NULL == dv) && (0 != (options & RMO_DV_ALLOWED)))
+      dv = GNUNET_CONTAINER_multipeermap_get (dv_routes, target);
+  }
+  if ((NULL == n) && (NULL == dv))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Cannot route message of type %u to %s: no route\n",
+                ntohs (hdr->type),
+                GNUNET_i2s (target));
+    GNUNET_STATISTICS_update (GST_stats,
+                              "# Messages dropped in routing: no acceptable method",
+                              1,
+                              GNUNET_NO);
+    return GNUNET_TIME_UNIT_FOREVER_REL;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Routing message of type %u to %s with options %X\n",
+              ntohs (hdr->type),
+              GNUNET_i2s (target),
+              (unsigned int) options);
+  /* If both dv and n are possible and we must choose:
+     flip a coin for the choice between the two; for now 50/50 */
+  if ((NULL != n) && (NULL != dv) && (0 == (options & RMO_REDUNDANT)))
+  {
+    if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 2))
+      n = NULL;
+    else
+      dv = NULL;
+  }
+  if ((NULL != n) && (NULL != dv))
+    options &= ~RMO_REDUNDANT; /* We will do one DV and one direct, that's
+                                  enough for redundancy, so clear the flag. */
+  rtt1 = GNUNET_TIME_UNIT_FOREVER_REL;
+  rtt2 = GNUNET_TIME_UNIT_FOREVER_REL;
+  if (NULL != n)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Try to route message of type %u to %s without fc via neighbour\n",
+                ntohs (hdr->type),
+                GNUNET_i2s (target));
+    rtt1 = route_via_neighbour (n, hdr, options);
+  }
+  if (NULL != dv)
+  {
+    struct DistanceVectorHop *hops[2];
+    unsigned int res;
+
+    res = pick_random_dv_hops (dv,
+                               options,
+                               hops,
+                               (0 == (options & RMO_REDUNDANT)) ? 1 : 2);
+    if (0 == res)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Failed to route message, could not determine DV path\n");
+      return rtt1;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "encapsulate_for_dv 1\n");
+    rtt2 = encapsulate_for_dv (dv,
+                               res,
+                               hops,
+                               hdr,
+                               &send_dv_to_neighbour,
+                               NULL,
+                               options & (~RMO_REDUNDANT),
+                               GNUNET_YES);
+  }
+  return GNUNET_TIME_relative_min (rtt1, rtt2);
+}
+
+
+static void
+consider_sending_fc (void *cls);
+
+/**
+ * Something changed on the virtual link with respect to flow
+ * control. Consider retransmitting the FC window size.
+ *
+ * @param cls a `struct VirtualLink` to work with
+ */
+static void
+task_consider_sending_fc (void *cls)
+{
+  struct VirtualLink *vl = cls;
+  vl->fc_retransmit_task = NULL;
+  consider_sending_fc (cls);
+}
+
+
+static char *
+get_address_without_port (const char *address);
+
+
+struct AddGlobalAddressesContext
+{
+  size_t off;
+  char *tgnas;
+};
+
+
+static enum GNUNET_GenericReturnValue
+add_global_addresses (void *cls,
+                      const struct GNUNET_PeerIdentity *pid,
+                      void *value)
+{
+  struct AddGlobalAddressesContext *ctx = cls;
+  struct TransportGlobalNattedAddress *tgna = value;
+  char *addr = (char *) &tgna[1];
+  size_t address_len = strlen (addr);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "sending address %s length %lu\n",
+              addr,
+              address_len);
+  tgna = GNUNET_malloc (sizeof (struct TransportGlobalNattedAddress) + address_len);
+  tgna->address_length = htonl (address_len);
+  GNUNET_memcpy (&tgna[1], addr, address_len);
+  GNUNET_memcpy (&(ctx->tgnas[ctx->off]), tgna, sizeof (struct TransportGlobalNattedAddress) + address_len);
+  GNUNET_free (tgna);
+  ctx->off += sizeof(struct TransportGlobalNattedAddress) + address_len;
+
+  return GNUNET_OK;
+}
+
+
+/**
+ * Something changed on the virtual link with respect to flow
+ * control. Consider retransmitting the FC window size.
+ *
+ * @param cls a `struct VirtualLink` to work with
+ */
+static void
+consider_sending_fc (void *cls)
+{
+  struct VirtualLink *vl = cls;
+  struct GNUNET_TIME_Absolute monotime;
+  struct TransportFlowControlMessage *fc;
+  struct GNUNET_TIME_Relative duration;
+  struct GNUNET_TIME_Relative rtt;
+  struct Neighbour *n = vl->n;
+
+  if (0 < n->number_of_addresses)
+  {
+    size_t addresses_size =
+      n->number_of_addresses * sizeof (struct TransportGlobalNattedAddress) + n->size_of_global_addresses;
+    char *tgnas = GNUNET_malloc (addresses_size);
+    struct AddGlobalAddressesContext ctx;
+    ctx.off = 0;
+    ctx.tgnas = tgnas;
+
+    fc = GNUNET_malloc (sizeof (struct TransportFlowControlMessage) + addresses_size);
+    fc->header.size = htons (sizeof(struct TransportFlowControlMessage) + addresses_size);
+    fc->size_of_addresses = htonl (n->size_of_global_addresses);
+    fc->number_of_addresses = htonl (n->number_of_addresses);
+    GNUNET_CONTAINER_multipeermap_iterate (n->natted_addresses,
+                                           &add_global_addresses,
+                                           &ctx);
+    GNUNET_memcpy (&fc[1], tgnas, addresses_size);
+    GNUNET_free (tgnas);
+  }
+  else
+  {
+    fc = GNUNET_malloc (sizeof (struct TransportFlowControlMessage));
+    fc->header.size = htons (sizeof(struct TransportFlowControlMessage));
+  }
+
+  duration = GNUNET_TIME_absolute_get_duration (vl->last_fc_transmission);
+  /* OPTIMIZE-FC-BDP: decide sane criteria on when to do this, instead of doing
+     it always! */
+  /* For example, we should probably ONLY do this if a bit more than
+     an RTT has passed, or if the window changed "significantly" since
+     then. See vl->last_fc_rtt! NOTE: to do this properly, we also
+     need an estimate for the bandwidth-delay-product for the entire
+     VL, as that determines "significantly". We have the delay, but
+     the bandwidth statistics need to be added for the VL!*/(void) duration;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending FC seq %u to %s with new window %llu\n",
+              (unsigned int) vl->fc_seq_gen,
+              GNUNET_i2s (&vl->target),
+              (unsigned long long) vl->incoming_fc_window_size);
+  monotime = GNUNET_TIME_absolute_get_monotonic (GST_cfg);
+  vl->last_fc_transmission = monotime;
+  fc->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL);
+  fc->seq = htonl (vl->fc_seq_gen++);
+  fc->inbound_window_size = GNUNET_htonll (vl->incoming_fc_window_size
+                                          + vl->incoming_fc_window_size_used
+                                          + vl->incoming_fc_window_size_loss);
+  fc->outbound_sent = GNUNET_htonll (vl->outbound_fc_window_size_used);
+  fc->outbound_window_size = GNUNET_htonll (vl->outbound_fc_window_size);
+  fc->sender_time = GNUNET_TIME_absolute_hton (monotime);
+  rtt = route_control_message_without_fc (vl, &fc->header, RMO_DV_ALLOWED);
+  if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == rtt.rel_value_us)
+  {
+    rtt = GNUNET_TIME_UNIT_SECONDS;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "FC retransmission to %s failed, will retry in %s\n",
+                GNUNET_i2s (&vl->target),
+                GNUNET_STRINGS_relative_time_to_string (rtt, GNUNET_YES));
+    vl->last_fc_rtt = GNUNET_TIME_UNIT_ZERO;
+  }
+  else
+  {
+    /* OPTIMIZE-FC-BDP: rtt is not ideal, we can do better! */
+    vl->last_fc_rtt = rtt;
+  }
+  if (NULL != vl->fc_retransmit_task)
+    GNUNET_SCHEDULER_cancel (vl->fc_retransmit_task);
+  if (MAX_FC_RETRANSMIT_COUNT == vl->fc_retransmit_count)
+  {
+    rtt = GNUNET_TIME_UNIT_MINUTES;
+    vl->fc_retransmit_count = 0;
+  }
+  vl->fc_retransmit_task =
+    GNUNET_SCHEDULER_add_delayed (rtt, &task_consider_sending_fc, vl);
+  vl->fc_retransmit_count++;
+  GNUNET_free (fc);
+}
+
+
+/**
+ * There is a message at the head of the pending messages for @a vl
+ * which may be ready for transmission. Check if a queue is ready to
+ * take it.
+ *
+ * This function must (1) check for flow control to ensure that we can
+ * right now send to @a vl, (2) check that the pending message in the
+ * queue is actually eligible, (3) determine if any applicable queue
+ * (direct neighbour or DVH path) is ready to accept messages, and
+ * (4) prioritize based on the preferences associated with the
+ * pending message.
+ *
+ * So yeah, easy.
+ *
+ * @param vl virtual link where we should check for transmission
+ */
+static void
+check_vl_transmission (struct VirtualLink *vl)
+{
+  struct Neighbour *n = vl->n;
+  struct DistanceVector *dv = vl->dv;
+  struct GNUNET_TIME_Absolute now;
+  struct VirtualLink *vl_next_hop;
+  int elig;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "check_vl_transmission to target %s\n",
+              GNUNET_i2s (&vl->target));
+  /* Check that we have an eligible pending message!
+     (cheaper than having #transmit_on_queue() find out!) */
+  elig = GNUNET_NO;
+  for (struct PendingMessage *pm = vl->pending_msg_head; NULL != pm;
+       pm = pm->next_vl)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "check_vl_transmission loop\n");
+    if (NULL != pm->qe)
+      continue;   /* not eligible, is in a queue! */
+    if (pm->bytes_msg + vl->outbound_fc_window_size_used >
+        vl->outbound_fc_window_size)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Stalled message %" PRIu64
+                  " transmission on VL %s due to flow control: %llu < %llu\n",
+                  pm->logging_uuid,
+                  GNUNET_i2s (&vl->target),
+                  (unsigned long long) vl->outbound_fc_window_size,
+                  (unsigned long long) (pm->bytes_msg
+                                        + vl->outbound_fc_window_size_used));
+      consider_sending_fc (vl);
+      return;     /* We have a message, but flow control says "nope" */
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Target window on VL %s not stalled. Scheduling transmission on queue\n",
+                GNUNET_i2s (&vl->target));
+    /* Notify queues at direct neighbours that we are interested */
+    now = GNUNET_TIME_absolute_get ();
+    if (NULL != n)
+    {
+      for (struct Queue *queue = n->queue_head; NULL != queue;
+           queue = queue->next_neighbour)
+      {
+        if ((GNUNET_YES == queue->idle) &&
+            (queue->validated_until.abs_value_us > now.abs_value_us))
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Direct neighbour %s not stalled\n",
+                      GNUNET_i2s (&n->pid));
+          schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
+                                      queue,
+                                      GNUNET_SCHEDULER_PRIORITY_DEFAULT);
+          elig = GNUNET_YES;
+        }
+        else
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Neighbour Queue QID: %u (%u) busy or invalid\n",
+                      queue->qid,
+                      queue->idle);
+      }
+    }
+    /* Notify queues via DV that we are interested */
+    if (NULL != dv)
+    {
+      /* Do DV with lower scheduler priority, which effectively means that
+         IF a neighbour exists and is available, we prefer it. */
+      for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
+           pos = pos->next_dv)
+      {
+        struct Neighbour *nh = pos->next_hop;
+
+
+        if (pos->path_valid_until.abs_value_us <= now.abs_value_us)
+          continue;   /* skip this one: path not validated */
+        else
+        {
+          vl_next_hop = lookup_virtual_link (&nh->pid);
+          GNUNET_assert (NULL != vl_next_hop);
+          if (pm->bytes_msg + vl_next_hop->outbound_fc_window_size_used >
+              vl_next_hop->outbound_fc_window_size)
+          {
+            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                        "Stalled message %" PRIu64
+                        " transmission on next hop %s due to flow control: %llu < %llu\n",
+                        pm->logging_uuid,
+                        GNUNET_i2s (&vl_next_hop->target),
+                        (unsigned long
+                         long) vl_next_hop->outbound_fc_window_size,
+                        (unsigned long long) (pm->bytes_msg
+                                              + vl_next_hop->
+                                              outbound_fc_window_size_used));
+            consider_sending_fc (vl_next_hop);
+            continue; /* We have a message, but flow control says "nope" for the first hop of this path */
+          }
+          for (struct Queue *queue = nh->queue_head; NULL != queue;
+               queue = queue->next_neighbour)
+            if ((GNUNET_YES == queue->idle) &&
+                (queue->validated_until.abs_value_us > now.abs_value_us))
+            {
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          "Next hop neighbour %s not stalled\n",
+                          GNUNET_i2s (&nh->pid));
+              schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
+                                          queue,
+                                          GNUNET_SCHEDULER_PRIORITY_BACKGROUND);
+              elig = GNUNET_YES;
+            }
+            else
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          "DV Queue QID: %u (%u) busy or invalid\n",
+                          queue->qid,
+                          queue->idle);
+        }
+      }
+    }
+    if (GNUNET_YES == elig)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Eligible message %" PRIu64 " of size %u to %s: %llu/%llu\n",
+                  pm->logging_uuid,
+                  pm->bytes_msg,
+                  GNUNET_i2s (&vl->target),
+                  (unsigned long long) vl->outbound_fc_window_size,
+                  (unsigned long long) (pm->bytes_msg
+                                        + vl->outbound_fc_window_size_used));
+    break;
+  }
+}
+
+
+/**
+ * Client asked for transmission to a peer.  Process the request.
+ *
+ * @param cls the client
+ * @param obm the send message that was sent
+ */
+static void
+handle_client_send (void *cls, const struct OutboundMessage *obm)
+{
+  struct TransportClient *tc = cls;
+  struct PendingMessage *pm;
+  const struct GNUNET_MessageHeader *obmm;
+  uint32_t bytes_msg;
+  struct VirtualLink *vl;
+  enum GNUNET_MQ_PriorityPreferences pp;
+
+  GNUNET_assert (CT_CORE == tc->type);
+  obmm = (const struct GNUNET_MessageHeader *) &obm[1];
+  bytes_msg = ntohs (obmm->size);
+  pp = (enum GNUNET_MQ_PriorityPreferences) ntohl (obm->priority);
+  vl = lookup_virtual_link (&obm->peer);
+  if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Don't have %s as a neighbour (anymore).\n",
+                GNUNET_i2s (&obm->peer));
+    /* Failure: don't have this peer as a neighbour (anymore).
+       Might have gone down asynchronously, so this is NOT
+       a protocol violation by CORE. Still count the event,
+       as this should be rare. */
+    GNUNET_SERVICE_client_continue (tc->client);
+    GNUNET_STATISTICS_update (GST_stats,
+                              "# messages dropped (neighbour unknown)",
+                              1,
+                              GNUNET_NO);
+    return;
+  }
+
+  pm = GNUNET_malloc (sizeof(struct PendingMessage) + bytes_msg);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "1 created pm %p storing vl %p\n",
+              pm,
+              vl);
+  pm->logging_uuid = logging_uuid_gen++;
+  pm->prefs = pp;
+  pm->client = tc;
+  pm->vl = vl;
+  pm->bytes_msg = bytes_msg;
+  memcpy (&pm[1], obmm, bytes_msg);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending message of type %u  with %u bytes as <%" PRIu64
+              "> to %s\n",
+              ntohs (obmm->type),
+              bytes_msg,
+              pm->logging_uuid,
+              GNUNET_i2s (&obm->peer));
+  GNUNET_CONTAINER_MDLL_insert (client,
+                                tc->details.core.pending_msg_head,
+                                tc->details.core.pending_msg_tail,
+                                pm);
+  GNUNET_CONTAINER_MDLL_insert (vl,
+                                vl->pending_msg_head,
+                                vl->pending_msg_tail,
+                                pm);
+  check_vl_transmission (vl);
+  GNUNET_SERVICE_client_continue (tc->client);
+}
+
+
+/**
+ * Communicator requests backchannel transmission.  Process the request.
+ * Just repacks it into our `struct TransportBackchannelEncapsulationMessage *`
+ * (which for now has exactly the same format, only a different message type)
+ * and passes it on for routing.
+ *
+ * @param cls the client
+ * @param cb the send message that was sent
+ */
+static void
+handle_communicator_backchannel (
+  void *cls,
+  const struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb)
+{
+  struct Neighbour *n;
+  struct VirtualLink *vl;
+  struct TransportClient *tc = cls;
+  const struct GNUNET_MessageHeader *inbox =
+    (const struct GNUNET_MessageHeader *) &cb[1];
+  uint16_t isize = ntohs (inbox->size);
+  const char *is = ((const char *) &cb[1]) + isize;
+  size_t slen = strlen (is) + 1;
+  char
+    mbuf[slen + isize
+         + sizeof(struct
+                  TransportBackchannelEncapsulationMessage)] GNUNET_ALIGN;
+  struct TransportBackchannelEncapsulationMessage *be =
+    (struct TransportBackchannelEncapsulationMessage *) mbuf;
+
+  /* 0-termination of 'is' was checked already in
+   #check_communicator_backchannel() */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Preparing backchannel transmission to %s:%s of type %u and size %u\n",
+              GNUNET_i2s (&cb->pid),
+              is,
+              ntohs (inbox->type),
+              ntohs (inbox->size));
+  /* encapsulate and encrypt message */
+  be->header.type =
+    htons (GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION);
+  be->header.size = htons (sizeof(mbuf));
+  memcpy (&be[1], inbox, isize);
+  memcpy (&mbuf[sizeof(struct TransportBackchannelEncapsulationMessage)
+                + isize],
+          is,
+          strlen (is) + 1);
+  // route_control_message_without_fc (&cb->pid, &be->header, RMO_DV_ALLOWED);
+  vl = lookup_virtual_link (&cb->pid);
+  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
+  {
+    route_control_message_without_fc (vl, &be->header, RMO_DV_ALLOWED);
+  }
+  else
+  {
+    /* Use route via neighbour */
+    n = lookup_neighbour (&cb->pid);
+    if (NULL != n)
+      route_via_neighbour (
+        n,
+        &be->header,
+        RMO_NONE);
+  }
+  GNUNET_SERVICE_client_continue (tc->client);
+}
+
+
+/**
+ * Address of our peer added.  Test message is well-formed.
+ *
+ * @param cls the client
+ * @param aam the send message that was sent
+ * @return #GNUNET_OK if message is well-formed
+ */
+static int
+check_add_address (void *cls,
+                   const struct GNUNET_TRANSPORT_AddAddressMessage *aam)
+{
+  struct TransportClient *tc = cls;
+
+  if (CT_COMMUNICATOR != tc->type)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_MQ_check_zero_termination (aam);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Ask peerstore to store our address.
+ *
+ * @param cls an `struct AddressListEntry *`
+ */
+static void
+store_pi (void *cls);
+
+
+/**
+ * Function called when peerstore is done storing our address.
+ *
+ * @param cls a `struct AddressListEntry`
+ * @param success #GNUNET_YES if peerstore was successful
+ */
+static void
+peerstore_store_own_cb (void *cls, int success)
+{
+  struct AddressListEntry *ale = cls;
+
+  ale->sc = NULL;
+  if (GNUNET_YES != success)
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to store our own address `%s' in peerstore!\n",
+                ale->address);
+  else
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Successfully stored our own address `%s' in peerstore!\n",
+                ale->address);
+  /* refresh period is 1/4 of expiration time, that should be plenty
+     without being excessive. */
+  ale->st =
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide (ale->expiration,
+                                                               4ULL),
+                                  &store_pi,
+                                  ale);
+}
+
+
+static void
+shc_cont (void *cls, int success)
+{
+  struct AddressListEntry *ale = cls;
+  struct GNUNET_TIME_Absolute expiration;
+
+  expiration = GNUNET_TIME_relative_to_absolute (ale->expiration);
+  ale->sc = GNUNET_PEERSTORE_store (peerstore,
+                                    "transport",
+                                    &GST_my_identity,
+                                    GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY,
+                                    ale->signed_address,
+                                    ale->signed_address_len,
+                                    expiration,
+                                    GNUNET_PEERSTORE_STOREOPTION_MULTIPLE,
+                                    &peerstore_store_own_cb,
+                                    ale);
+  if (NULL == ale->sc)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Failed to store our address `%s' with peerstore\n",
+                ale->address);
+    ale->st = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                            &store_pi,
+                                            ale);
+  }
+}
+
+
+/**
+ * Ask peerstore to store our address.
+ *
+ * @param cls an `struct AddressListEntry *`
+ */
+static void
+store_pi (void *cls)
+{
+  struct AddressListEntry *ale = cls;
+  struct GNUNET_MQ_Envelope *env;
+  const struct GNUNET_MessageHeader *msg;
+  const char *dash;
+  char *address_uri;
+  char *prefix = GNUNET_HELLO_address_to_prefix (ale->address);
+  unsigned int add_success;
+
+  dash = strchr (ale->address, '-');
+  GNUNET_assert (NULL != dash);
+  dash++;
+  GNUNET_asprintf (&address_uri,
+                   "%s://%s",
+                   prefix,
+                   dash);
+  GNUNET_free (prefix);
+  ale->st = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Storing our address `%s' in peerstore until %s!\n",
+              ale->address,
+              GNUNET_STRINGS_absolute_time_to_string (hello_mono_time));
+  add_success = GNUNET_HELLO_builder_add_address (GST_my_hello,
+                                                  address_uri);
+  if (GNUNET_OK != add_success)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Storing our address `%s' %s\n",
+                address_uri,
+                GNUNET_NO == add_success ? "not done" : "failed");
+    GNUNET_free (address_uri);
+    return;
+  }
+  else
+  {
+
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Storing our address `%s'\n",
+                address_uri);
+  }
+  // FIXME hello_mono_time used here?? What about expiration in ale?
+  GNUNET_HELLO_sign_address (ale->address,
+                             ale->nt,
+                             hello_mono_time,
+                             GST_my_private_key,
+                             &ale->signed_address,
+                             &ale->signed_address_len);
+  GNUNET_free (address_uri);
+  env = GNUNET_HELLO_builder_to_env (GST_my_hello,
+                                     GST_my_private_key,
+                                     GNUNET_TIME_UNIT_ZERO);
+  msg = GNUNET_MQ_env_get_msg (env);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "store_pi 1\n");
+  ale->shc = GNUNET_PEERSTORE_hello_add (peerstore,
+                                         msg,
+                                         shc_cont,
+                                         ale);
+  GNUNET_free (env);
+}
+
+
+static struct AddressListEntry *
+create_address_entry (struct TransportClient *tc,
+                      struct GNUNET_TIME_Relative expiration,
+                      enum GNUNET_NetworkType nt,
+                      const char *address,
+                      uint32_t aid,
+                      size_t slen)
+{
+  struct AddressListEntry *ale;
+
+  ale = GNUNET_malloc (sizeof(struct AddressListEntry) + slen);
+  ale->tc = tc;
+  ale->address = (const char *) &ale[1];
+  ale->expiration = expiration;
+  ale->aid = aid;
+  ale->nt = nt;
+  memcpy (&ale[1], address, slen);
+  ale->st = GNUNET_SCHEDULER_add_now (&store_pi, ale);
+
+  return ale;
+}
+
+
+/**
+ * Address of our peer added.  Process the request.
+ *
+ * @param cls the client
+ * @param aam the send message that was sent
+ */
+static void
+handle_add_address (void *cls,
+                    const struct GNUNET_TRANSPORT_AddAddressMessage *aam)
+{
+  struct TransportClient *tc = cls;
+  struct AddressListEntry *ale;
+  size_t slen;
+
+  /* 0-termination of &aam[1] was checked in #check_add_address */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Communicator added address `%s'!\n",
+              (const char *) &aam[1]);
+  slen = ntohs (aam->header.size) - sizeof(*aam);
+  ale = create_address_entry (tc,
+                        GNUNET_TIME_relative_ntoh (aam->expiration),
+                        (enum GNUNET_NetworkType) ntohl (aam->nt),
+                        (const char *) &aam[1],
+                        aam->aid,
+                        slen);
+  GNUNET_CONTAINER_DLL_insert (tc->details.communicator.addr_head,
+                               tc->details.communicator.addr_tail,
+                               ale);
+  GNUNET_SERVICE_client_continue (tc->client);
+}
+
+
+/**
+ * Address of our peer deleted.  Process the request.
+ *
+ * @param cls the client
+ * @param dam the send message that was sent
+ */
+static void
+handle_del_address (void *cls,
+                    const struct GNUNET_TRANSPORT_DelAddressMessage *dam)
+{
+  struct TransportClient *tc = cls;
+  struct AddressListEntry *alen;
+
+  if (CT_COMMUNICATOR != tc->type)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (tc->client);
+    return;
+  }
+  for (struct AddressListEntry *ale = tc->details.communicator.addr_head;
+       NULL != ale;
+       ale = alen)
+  {
+    alen = ale->next;
+    if (dam->aid != ale->aid)
+      continue;
+    GNUNET_assert (ale->tc == tc);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Communicator deleted address `%s'!\n",
+                ale->address);
+    free_address_list_entry (ale);
+    GNUNET_SERVICE_client_continue (tc->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Communicator removed address we did not even have.\n");
+  GNUNET_SERVICE_client_continue (tc->client);
+  // GNUNET_SERVICE_client_drop (tc->client);
+}
+
+
+/**
+ * Given an inbound message @a msg from a communicator @a cmc,
+ * demultiplex it based on the type calling the right handler.
+ *
+ * @param cmc context for demultiplexing
+ * @param msg message to demultiplex
+ */
+static void
+demultiplex_with_cmc (struct CommunicatorMessageContext *cmc);
+
+
+/**
+ * Function called when we are done giving a message of a certain
+ * size to CORE and should thus decrement the number of bytes of
+ * RAM reserved for that peer's MQ.
+ *
+ * @param cls a `struct CoreSentContext`
+ */
+static void
+core_env_sent_cb (void *cls)
+{
+  struct CoreSentContext *ctx = cls;
+  struct VirtualLink *vl = ctx->vl;
+
+  if (NULL == vl)
+  {
+    /* lost the link in the meantime, ignore */
+    GNUNET_free (ctx);
+    return;
+  }
+  GNUNET_CONTAINER_DLL_remove (vl->csc_head, vl->csc_tail, ctx);
+  GNUNET_assert (vl->incoming_fc_window_size_ram >= ctx->size);
+  vl->incoming_fc_window_size_ram -= ctx->size;
+  vl->incoming_fc_window_size_used += ctx->isize;
+  consider_sending_fc (vl);
+  GNUNET_free (ctx);
+}
+
+
+static void
+finish_handling_raw_message (struct VirtualLink *vl,
+                             const struct GNUNET_MessageHeader *mh,
+                             struct CommunicatorMessageContext *cmc,
+                             unsigned int free_cmc)
+{
+  uint16_t size = ntohs (mh->size);
+  int have_core;
+
+  if (vl->incoming_fc_window_size_ram > UINT_MAX - size)
+  {
+    GNUNET_STATISTICS_update (GST_stats,
+                              "# CORE messages dropped (FC arithmetic overflow)",
+                              1,
+                              GNUNET_NO);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "CORE messages of type %u with %u bytes dropped (FC arithmetic overflow)\n",
+                (unsigned int) ntohs (mh->type),
+                (unsigned int) ntohs (mh->size));
+    if (GNUNET_YES == free_cmc)
+      finish_cmc_handling_with_continue (cmc, GNUNET_YES);
+    return;
+  }
+  if (vl->incoming_fc_window_size_ram + size > vl->available_fc_window_size)
+  {
+    GNUNET_STATISTICS_update (GST_stats,
+                              "# CORE messages dropped (FC window overflow)",
+                              1,
+                              GNUNET_NO);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "CORE messages of type %u with %u bytes dropped (FC window overflow)\n",
+                (unsigned int) ntohs (mh->type),
+                (unsigned int) ntohs (mh->size));
+    if (GNUNET_YES == free_cmc)
+      finish_cmc_handling_with_continue (cmc, GNUNET_YES);
+    return;
+  }
+
+  /* Forward to all CORE clients */
+  have_core = GNUNET_NO;
+  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
+  {
+    struct GNUNET_MQ_Envelope *env;
+    struct InboundMessage *im;
+    struct CoreSentContext *ctx;
+
+    if (CT_CORE != tc->type)
+      continue;
+    vl->incoming_fc_window_size_ram += size;
+    env = GNUNET_MQ_msg_extra (im, size, GNUNET_MESSAGE_TYPE_TRANSPORT_RECV);
+    ctx = GNUNET_new (struct CoreSentContext);
+    ctx->vl = vl;
+    ctx->size = size;
+    ctx->isize = (GNUNET_NO == have_core) ? size : 0;
+    have_core = GNUNET_YES;
+    GNUNET_CONTAINER_DLL_insert (vl->csc_head, vl->csc_tail, ctx);
+    GNUNET_MQ_notify_sent (env, &core_env_sent_cb, ctx);
+    im->peer = cmc->im.sender;
+    memcpy (&im[1], mh, size);
+    GNUNET_MQ_send (tc->mq, env);
+    vl->core_recv_window--;
+  }
+  if (GNUNET_NO == have_core)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Dropped message to CORE: no CORE client connected!\n");
+    /* Nevertheless, count window as used, as it is from the
+       perspective of the other peer! */
+    vl->incoming_fc_window_size_used += size;
+    /* TODO-M1 */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Dropped message of type %u with %u bytes to CORE: no CORE client connected!\n",
+                (unsigned int) ntohs (mh->type),
+                (unsigned int) ntohs (mh->size));
+    if (GNUNET_YES == free_cmc)
+      finish_cmc_handling_with_continue (cmc, GNUNET_YES);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Delivered message from %s of type %u to CORE recv window %d\n",
+              GNUNET_i2s (&cmc->im.sender),
+              ntohs (mh->type),
+              vl->core_recv_window);
+  if (vl->core_recv_window > 0)
+  {
+    if (GNUNET_YES == free_cmc)
+      finish_cmc_handling_with_continue (cmc, GNUNET_YES);
+    return;
+  }
+  /* Wait with calling #finish_cmc_handling(cmc) until the message
+     was processed by CORE MQs (for CORE flow control)! */
+  if (GNUNET_YES == free_cmc)
+    GNUNET_CONTAINER_DLL_insert (vl->cmc_head, vl->cmc_tail, cmc);
+}
+
+
+/**
+ * Communicator gave us an unencapsulated message to pass as-is to
+ * CORE.  Process the request.
+ *
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
+ * @param mh the message that was received
+ */
+static void
+handle_raw_message (void *cls, const struct GNUNET_MessageHeader *mh)
+{
+  struct CommunicatorMessageContext *cmc = cls;
+  // struct CommunicatorMessageContext *cmc_copy =
+  // GNUNET_new (struct CommunicatorMessageContext);
+  struct GNUNET_MessageHeader *mh_copy;
+  struct RingBufferEntry *rbe;
+  struct VirtualLink *vl;
+  uint16_t size = ntohs (mh->size);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Handling raw message of type %u with %u bytes\n",
+              (unsigned int) ntohs (mh->type),
+              (unsigned int) ntohs (mh->size));
+
+  if ((size > UINT16_MAX - sizeof(struct InboundMessage)) ||
+      (size < sizeof(struct GNUNET_MessageHeader)))
+  {
+    struct GNUNET_SERVICE_Client *client = cmc->tc->client;
+
+    GNUNET_break (0);
+    finish_cmc_handling (cmc);
+    GNUNET_SERVICE_client_drop (client);
+    return;
+  }
+  vl = lookup_virtual_link (&cmc->im.sender);
+  if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
+  {
+    /* FIXME: sender is giving us messages for CORE but we don't have
+       the link up yet! I *suspect* this can happen right now (i.e.
+       sender has verified us, but we didn't verify sender), but if
+       we pass this on, CORE would be confused (link down, messages
+       arrive).  We should investigate more if this happens often,
+       or in a persistent manner, and possibly do "something" about
+       it. Thus logging as error for now. */
+
+    mh_copy = GNUNET_malloc (size);
+    rbe = GNUNET_new (struct RingBufferEntry);
+    rbe->cmc = cmc;
+    /*cmc_copy->tc = cmc->tc;
+       cmc_copy->im = cmc->im;*/
+    GNUNET_memcpy (mh_copy, mh, size);
+
+    rbe->mh = mh_copy;
+
+    if (GNUNET_YES == is_ring_buffer_full)
+    {
+      struct RingBufferEntry *rbe_old = ring_buffer[ring_buffer_head];
+      GNUNET_free (rbe_old->cmc);
+      GNUNET_free (rbe_old->mh);
+      GNUNET_free (rbe_old);
+    }
+    ring_buffer[ring_buffer_head] = rbe;// cmc_copy;
+    // cmc_copy->mh = (const struct GNUNET_MessageHeader *) mh_copy;
+    cmc->mh = (const struct GNUNET_MessageHeader *) mh_copy;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Storing message for %s and type %u (%u) in ring buffer head %u is full %u\n",
+                GNUNET_i2s (&cmc->im.sender),
+                (unsigned int) ntohs (mh->type),
+                (unsigned int) ntohs (mh_copy->type),
+                ring_buffer_head,
+                is_ring_buffer_full);
+    if (RING_BUFFER_SIZE - 1 == ring_buffer_head)
+    {
+      ring_buffer_head = 0;
+      is_ring_buffer_full = GNUNET_YES;
+    }
+    else
+      ring_buffer_head++;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%u items stored in ring buffer\n",
+                GNUNET_YES == is_ring_buffer_full ? RING_BUFFER_SIZE :
+                ring_buffer_head);
+
+    /*GNUNET_break_op (0);
+    GNUNET_STATISTICS_update (GST_stats,
+                              "# CORE messages dropped (virtual link still down)",
+                              1,
+                              GNUNET_NO);
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "CORE messages of type %u with %u bytes dropped (virtual link still down)\n",
+                (unsigned int) ntohs (mh->type),
+                (unsigned int) ntohs (mh->size));
+    finish_cmc_handling (cmc);*/
+    finish_cmc_handling_with_continue (cmc, GNUNET_NO);
+    cmc->continue_send = GNUNET_YES;
+    // GNUNET_free (cmc);
+    return;
+  }
+  finish_handling_raw_message (vl, mh, cmc, GNUNET_YES);
+}
+
+
+/**
+ * Communicator gave us a fragment box.  Check the message.
+ *
+ * @param cls a `struct CommunicatorMessageContext`
+ * @param fb the send message that was sent
+ * @return #GNUNET_YES if message is well-formed
+ */
+static int
+check_fragment_box (void *cls, const struct TransportFragmentBoxMessage *fb)
+{
+  uint16_t size = ntohs (fb->header.size);
+  uint16_t bsize = size - sizeof(*fb);
+
+  (void) cls;
+  if (0 == bsize)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  if (bsize + ntohs (fb->frag_off) > ntohs (fb->msg_size))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  if (ntohs (fb->frag_off) >= ntohs (fb->msg_size))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * Clean up an idle cumulative acknowledgement data structure.
+ *
+ * @param cls a `struct AcknowledgementCummulator *`
+ */
+static void
+destroy_ack_cummulator (void *cls)
+{
+  struct AcknowledgementCummulator *ac = cls;
+
+  ac->task = NULL;
+  GNUNET_assert (0 == ac->num_acks);
+  GNUNET_assert (
+    GNUNET_YES ==
+    GNUNET_CONTAINER_multipeermap_remove (ack_cummulators, &ac->target, ac));
+  GNUNET_free (ac);
+}
+
+
+/**
+ * Do the transmission of a cumulative acknowledgement now.
+ *
+ * @param cls a `struct AcknowledgementCummulator *`
+ */
+static void
+transmit_cummulative_ack_cb (void *cls)
+{
+  struct Neighbour *n;
+  struct VirtualLink *vl;
+  struct AcknowledgementCummulator *ac = cls;
+  char buf[sizeof(struct TransportReliabilityAckMessage)
+           + ac->num_acks
+           * sizeof(struct TransportCummulativeAckPayloadP)] GNUNET_ALIGN;
+  struct TransportReliabilityAckMessage *ack =
+    (struct TransportReliabilityAckMessage *) buf;
+  struct TransportCummulativeAckPayloadP *ap;
+
+  ac->task = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending ACK with %u components to %s\n",
+              ac->num_acks,
+              GNUNET_i2s (&ac->target));
+  GNUNET_assert (0 < ac->num_acks);
+  ack->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK);
+  ack->header.size =
+    htons (sizeof(*ack)
+           + ac->num_acks * sizeof(struct TransportCummulativeAckPayloadP));
+  ack->ack_counter = htonl (ac->ack_counter += ac->num_acks);
+  ap = (struct TransportCummulativeAckPayloadP *) &ack[1];
+  for (unsigned int i = 0; i < ac->num_acks; i++)
+  {
+    ap[i].ack_uuid = ac->ack_uuids[i].ack_uuid;
+    ap[i].ack_delay = GNUNET_TIME_relative_hton (
+      GNUNET_TIME_absolute_get_duration (ac->ack_uuids[i].receive_time));
+  }
+  /*route_control_message_without_fc (
+    &ac->target,
+    &ack->header,
+    RMO_DV_ALLOWED);*/
+  vl = lookup_virtual_link (&ac->target);
+  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
+  {
+    route_control_message_without_fc (
+      vl,
+      &ack->header,
+      RMO_DV_ALLOWED);
+  }
+  else
+  {
+    /* Use route via neighbour */
+    n = lookup_neighbour (&ac->target);
+    if (NULL != n)
+      route_via_neighbour (
+        n,
+        &ack->header,
+        RMO_NONE);
+  }
+  ac->num_acks = 0;
+  ac->task = GNUNET_SCHEDULER_add_delayed (ACK_CUMMULATOR_TIMEOUT,
+                                           &destroy_ack_cummulator,
+                                           ac);
+}
+
+
+/**
+ * Transmit an acknowledgement for @a ack_uuid to @a pid delaying
+ * transmission by at most @a ack_delay.
+ *
+ * @param pid target peer
+ * @param ack_uuid UUID to ack
+ * @param max_delay how long can the ACK wait
+ */
+static void
+cummulative_ack (const struct GNUNET_PeerIdentity *pid,
+                 const struct AcknowledgementUUIDP *ack_uuid,
+                 struct GNUNET_TIME_Absolute max_delay)
+{
+  struct AcknowledgementCummulator *ac;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Scheduling ACK %s for transmission to %s\n",
+              GNUNET_uuid2s (&ack_uuid->value),
+              GNUNET_i2s (pid));
+  ac = GNUNET_CONTAINER_multipeermap_get (ack_cummulators, pid);
+  if (NULL == ac)
+  {
+    ac = GNUNET_new (struct AcknowledgementCummulator);
+    ac->target = *pid;
+    ac->min_transmission_time = max_delay;
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multipeermap_put (
+                     ack_cummulators,
+                     &ac->target,
+                     ac,
+                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  }
+  else
+  {
+    if (MAX_CUMMULATIVE_ACKS == ac->num_acks)
+    {
+      /* must run immediately, ack buffer full! */
+      transmit_cummulative_ack_cb (ac);
+    }
+    GNUNET_SCHEDULER_cancel (ac->task);
+    ac->min_transmission_time =
+      GNUNET_TIME_absolute_min (ac->min_transmission_time, max_delay);
+  }
+  GNUNET_assert (ac->num_acks < MAX_CUMMULATIVE_ACKS);
+  ac->ack_uuids[ac->num_acks].receive_time = GNUNET_TIME_absolute_get ();
+  ac->ack_uuids[ac->num_acks].ack_uuid = *ack_uuid;
+  ac->num_acks++;
+  ac->task = GNUNET_SCHEDULER_add_at (ac->min_transmission_time,
+                                      &transmit_cummulative_ack_cb,
+                                      ac);
+}
+
+
+/**
+ * Closure for #find_by_message_uuid.
+ */
+struct FindByMessageUuidContext
+{
+  /**
+   * UUID to look for.
+   */
+  struct MessageUUIDP message_uuid;
+
+  /**
+   * Set to the reassembly context if found.
+   */
+  struct ReassemblyContext *rc;
+};
+
+
+/**
+ * Iterator called to find a reassembly context by the message UUID in the
+ * multihashmap32.
+ *
+ * @param cls a `struct FindByMessageUuidContext`
+ * @param key a key (unused)
+ * @param value a `struct ReassemblyContext`
+ * @return #GNUNET_YES if not found, #GNUNET_NO if found
+ */
+static int
+find_by_message_uuid (void *cls, uint32_t key, void *value)
+{
+  struct FindByMessageUuidContext *fc = cls;
+  struct ReassemblyContext *rc = value;
+
+  (void) key;
+  if (0 == GNUNET_memcmp (&fc->message_uuid, &rc->msg_uuid))
+  {
+    fc->rc = rc;
+    return GNUNET_NO;
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * Communicator gave us a fragment.  Process the request.
+ *
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
+ * @param fb the message that was received
+ */
+static void
+handle_fragment_box (void *cls, const struct TransportFragmentBoxMessage *fb)
+{
+  struct CommunicatorMessageContext *cmc = cls;
+  struct VirtualLink *vl;
+  struct ReassemblyContext *rc;
+  const struct GNUNET_MessageHeader *msg;
+  uint16_t msize;
+  uint16_t fsize;
+  uint16_t frag_off;
+  char *target;
+  struct GNUNET_TIME_Relative cdelay;
+  struct FindByMessageUuidContext fc;
+
+  vl = lookup_virtual_link (&cmc->im.sender);
+  if ((NULL == vl) || (GNUNET_NO == vl->confirmed))
+  {
+    struct GNUNET_SERVICE_Client *client = cmc->tc->client;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No virtual link for %s to handle fragment\n",
+                GNUNET_i2s (&cmc->im.sender));
+    GNUNET_break (0);
+    finish_cmc_handling (cmc);
+    GNUNET_SERVICE_client_drop (client);
+    return;
+  }
+  if (NULL == vl->reassembly_map)
+  {
+    vl->reassembly_map = GNUNET_CONTAINER_multihashmap32_create (8);
+    vl->reassembly_heap =
+      GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+    vl->reassembly_timeout_task =
+      GNUNET_SCHEDULER_add_delayed (REASSEMBLY_EXPIRATION,
+                                    &reassembly_cleanup_task,
+                                    vl);
+  }
+  msize = ntohs (fb->msg_size);
+  fc.message_uuid = fb->msg_uuid;
+  fc.rc = NULL;
+  (void) GNUNET_CONTAINER_multihashmap32_get_multiple (vl->reassembly_map,
+                                                       fb->msg_uuid.uuid,
+                                                       &find_by_message_uuid,
+                                                       &fc);
+  fsize = ntohs (fb->header.size) - sizeof(*fb);
+  if (NULL == (rc = fc.rc))
+  {
+    rc = GNUNET_malloc (sizeof(*rc) + msize    /* reassembly payload buffer */
+                        + (msize + 7) / 8 * sizeof(uint8_t) /* bitfield */);
+    rc->msg_uuid = fb->msg_uuid;
+    rc->virtual_link = vl;
+    rc->msg_size = msize;
+    rc->reassembly_timeout =
+      GNUNET_TIME_relative_to_absolute (REASSEMBLY_EXPIRATION);
+    rc->last_frag = GNUNET_TIME_absolute_get ();
+    rc->hn = GNUNET_CONTAINER_heap_insert (vl->reassembly_heap,
+                                           rc,
+                                           rc->reassembly_timeout.abs_value_us);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multihashmap32_put (
+                     vl->reassembly_map,
+                     rc->msg_uuid.uuid,
+                     rc,
+                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+    target = (char *) &rc[1];
+    rc->bitfield = (uint8_t *) (target + rc->msg_size);
+    if (fsize != rc->msg_size)
+      rc->msg_missing = rc->msg_size;
+    else
+      rc->msg_missing = 0;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received fragment with size %u at offset %u/%u %u bytes missing from %s for NEW message %"
+                PRIu64 "\n",
+                fsize,
+                ntohs (fb->frag_off),
+                msize,
+                rc->msg_missing,
+                GNUNET_i2s (&cmc->im.sender),
+                fb->msg_uuid.uuid);
+  }
+  else
+  {
+    target = (char *) &rc[1];
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received fragment at offset %u/%u from %s for message %u\n",
+                ntohs (fb->frag_off),
+                msize,
+                GNUNET_i2s (&cmc->im.sender),
+                (unsigned int) fb->msg_uuid.uuid);
+  }
+  if (msize != rc->msg_size)
+  {
+    GNUNET_break (0);
+    finish_cmc_handling (cmc);
+    return;
+  }
+
+  /* reassemble */
+  if (0 == fsize)
+  {
+    GNUNET_break (0);
+    finish_cmc_handling (cmc);
+    return;
+  }
+  frag_off = ntohs (fb->frag_off);
+  if (frag_off + fsize > msize)
+  {
+    /* Fragment (plus fragment size) exceeds message size! */
+    GNUNET_break_op (0);
+    finish_cmc_handling (cmc);
+    return;
+  }
+  memcpy (&target[frag_off], &fb[1], fsize);
+  /* update bitfield and msg_missing */
+  for (unsigned int i = frag_off; i < frag_off + fsize; i++)
+  {
+    if (0 == (rc->bitfield[i / 8] & (1 << (i % 8))))
+    {
+      rc->bitfield[i / 8] |= (1 << (i % 8));
+      rc->msg_missing--;
+    }
+  }
+
+  /* Compute cumulative ACK */
+  cdelay = GNUNET_TIME_absolute_get_duration (rc->last_frag);
+  cdelay = GNUNET_TIME_relative_multiply (cdelay, rc->msg_missing / fsize);
+  if (0 == rc->msg_missing)
+    cdelay = GNUNET_TIME_UNIT_ZERO;
+  cummulative_ack (&cmc->im.sender,
+                   &fb->ack_uuid,
+                   GNUNET_TIME_relative_to_absolute (cdelay));
+  rc->last_frag = GNUNET_TIME_absolute_get ();
+  /* is reassembly complete? */
+  if (0 != rc->msg_missing)
+  {
+    finish_cmc_handling (cmc);
+    return;
+  }
+  /* reassembly is complete, verify result */
+  msg = (const struct GNUNET_MessageHeader *) &rc[1];
+  if (ntohs (msg->size) != rc->msg_size)
+  {
+    GNUNET_break (0);
+    free_reassembly_context (rc);
+    finish_cmc_handling (cmc);
+    return;
+  }
+  /* successful reassembly */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Fragment reassembly complete for message %u\n",
+              (unsigned int) fb->msg_uuid.uuid);
+  /* FIXME: check that the resulting msg is NOT a
+     DV Box or Reliability Box, as that is NOT allowed! */
+  cmc->mh = msg;
+  demultiplex_with_cmc (cmc);
+  /* FIXME-OPTIMIZE: really free here? Might be bad if fragments are still
+     en-route and we forget that we finished this reassembly immediately!
+     -> keep around until timeout?
+     -> shorten timeout based on ACK? */
+  free_reassembly_context (rc);
+}
+
+
+/**
+ * Communicator gave us a reliability box.  Check the message.
+ *
+ * @param cls a `struct CommunicatorMessageContext`
+ * @param rb the send message that was sent
+ * @return #GNUNET_YES if message is well-formed
+ */
+static int
+check_reliability_box (void *cls,
+                       const struct TransportReliabilityBoxMessage *rb)
+{
+  (void) cls;
+  const struct GNUNET_MessageHeader *inbox =  (const struct
+                                               GNUNET_MessageHeader *) &rb[1];
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "check_send_msg with size %u: inner msg type %u and size %u (%lu %lu)\n",
+              ntohs (rb->header.size),
+              ntohs (inbox->type),
+              ntohs (inbox->size),
+              sizeof (struct TransportReliabilityBoxMessage),
+              sizeof (struct GNUNET_MessageHeader));
+  GNUNET_MQ_check_boxed_message (rb);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Communicator gave us a reliability box.  Process the request.
+ *
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
+ * @param rb the message that was received
+ */
+static void
+handle_reliability_box (void *cls,
+                        const struct TransportReliabilityBoxMessage *rb)
+{
+  struct CommunicatorMessageContext *cmc = cls;
+  const struct GNUNET_MessageHeader *inbox =
+    (const struct GNUNET_MessageHeader *) &rb[1];
+  struct GNUNET_TIME_Relative rtt;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received reliability box from %s with UUID %s of type %u\n",
+              GNUNET_i2s (&cmc->im.sender),
+              GNUNET_uuid2s (&rb->ack_uuid.value),
+              (unsigned int) ntohs (inbox->type));
+  rtt = GNUNET_TIME_UNIT_SECONDS; /* FIXME: should base this on "RTT", but we
+                                     do not really have an RTT for the
+                                   * incoming* queue (should we have
+                                     the sender add it to the rb message?) */
+  cummulative_ack (
+    &cmc->im.sender,
+    &rb->ack_uuid,
+    (0 == ntohl (rb->ack_countdown))
+    ? GNUNET_TIME_UNIT_ZERO_ABS
+    : GNUNET_TIME_relative_to_absolute (
+      GNUNET_TIME_relative_divide (rtt, 8 /* FIXME: magic constant */)));
+  /* continue with inner message */
+  /* FIXME: check that inbox is NOT a DV Box, fragment or another
+     reliability box (not allowed!) */
+  cmc->mh = inbox;
+  demultiplex_with_cmc (cmc);
+}
+
+
+/**
+ * Check if we have advanced to another age since the last time.  If
+ * so, purge ancient statistics (more than GOODPUT_AGING_SLOTS before
+ * the current age)
+ *
+ * @param[in,out] pd data to update
+ * @param age current age
+ */
+static void
+update_pd_age (struct PerformanceData *pd, unsigned int age)
+{
+  unsigned int sage;
+
+  if (age == pd->last_age)
+    return; /* nothing to do */
+  sage = GNUNET_MAX (pd->last_age, age - 2 * GOODPUT_AGING_SLOTS);
+  for (unsigned int i = sage; i <= age - GOODPUT_AGING_SLOTS; i++)
+  {
+    struct TransmissionHistoryEntry *the = &pd->the[i % GOODPUT_AGING_SLOTS];
+
+    the->bytes_sent = 0;
+    the->bytes_received = 0;
+  }
+  pd->last_age = age;
+}
+
+
+/**
+ * Update @a pd based on the latest @a rtt and the number of bytes
+ * that were confirmed to be successfully transmitted.
+ *
+ * @param[in,out] pd data to update
+ * @param rtt latest round-trip time
+ * @param bytes_transmitted_ok number of bytes receiver confirmed as received
+ */
+static void
+update_performance_data (struct PerformanceData *pd,
+                         struct GNUNET_TIME_Relative rtt,
+                         uint16_t bytes_transmitted_ok)
+{
+  uint64_t nval = rtt.rel_value_us;
+  uint64_t oval = pd->aged_rtt.rel_value_us;
+  unsigned int age = get_age ();
+  struct TransmissionHistoryEntry *the = &pd->the[age % GOODPUT_AGING_SLOTS];
+
+  if (oval == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
+    pd->aged_rtt = rtt;
+  else
+    pd->aged_rtt.rel_value_us = (nval + 7 * oval) / 8;
+  update_pd_age (pd, age);
+  the->bytes_received += bytes_transmitted_ok;
+}
+
+
+/**
+ * We have successfully transmitted data via @a q, update metrics.
+ *
+ * @param q queue to update
+ * @param rtt round trip time observed
+ * @param bytes_transmitted_ok number of bytes successfully transmitted
+ */
+static void
+update_queue_performance (struct Queue *q,
+                          struct GNUNET_TIME_Relative rtt,
+                          uint16_t bytes_transmitted_ok)
+{
+  update_performance_data (&q->pd, rtt, bytes_transmitted_ok);
+}
+
+
+/**
+ * We have successfully transmitted data via @a dvh, update metrics.
+ *
+ * @param dvh distance vector path data to update
+ * @param rtt round trip time observed
+ * @param bytes_transmitted_ok number of bytes successfully transmitted
+ */
+static void
+update_dvh_performance (struct DistanceVectorHop *dvh,
+                        struct GNUNET_TIME_Relative rtt,
+                        uint16_t bytes_transmitted_ok)
+{
+  update_performance_data (&dvh->pd, rtt, bytes_transmitted_ok);
+}
+
+
+/**
+ * We have completed transmission of @a pm, remove it from
+ * the transmission queues (and if it is a fragment, continue
+ * up the tree as necessary).
+ *
+ * @param pm pending message that was transmitted
+ */
+static void
+completed_pending_message (struct PendingMessage *pm)
+{
+  struct PendingMessage *pos;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Complete transmission of message %" PRIu64 " %u\n",
+              pm->logging_uuid,
+              pm->pmt);
+  switch (pm->pmt)
+  {
+  case PMT_CORE:
+  case PMT_RELIABILITY_BOX:
+    /* Full message sent, we are done */
+    client_send_response (pm);
+    return;
+
+  case PMT_FRAGMENT_BOX:
+    /* Fragment sent over reliable channel */
+    pos = pm->frag_parent;
+    GNUNET_CONTAINER_MDLL_remove (frag, pos->head_frag, pos->tail_frag, pm);
+    free_pending_message (pm);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "pos frag_off %lu pos bytes_msg %lu pmt %u parent %u\n",
+                (unsigned long) pos->frag_off,
+                (unsigned long) pos->bytes_msg,
+                pos->pmt,
+                NULL == pos->frag_parent ? 1 : 0);
+    /* check if subtree is done */
+    while ((NULL == pos->head_frag) && (pos->frag_off == (pos->bytes_msg
+                                                          - sizeof(struct
+                                                                   TransportFragmentBoxMessage)))
+           &&
+           (NULL != pos->frag_parent))
+    {
+      pm = pos;
+      pos = pm->frag_parent;
+      if ((NULL == pos) && (PMT_DV_BOX == pm->pmt))
+      {
+        client_send_response (pm);
+        return;
+      }
+      else if (PMT_DV_BOX == pm->pmt)
+      {
+        client_send_response (pos);
+        return;
+      }
+      GNUNET_CONTAINER_MDLL_remove (frag, pos->head_frag, pos->tail_frag, pm);
+      free_pending_message (pm);
+    }
+
+    /* Was this the last applicable fragment? */
+    if ((NULL == pos->head_frag) && (NULL == pos->frag_parent || PMT_DV_BOX ==
+                                     pos->pmt) &&
+        (pos->frag_off == pos->bytes_msg))
+      client_send_response (pos);
+    return;
+
+  case PMT_DV_BOX:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Completed transmission of message %" PRIu64 " (DV Box)\n",
+                pm->logging_uuid);
+    if (NULL != pm->frag_parent)
+    {
+      pos = pm->frag_parent;
+      free_pending_message (pm);
+      pos->bpm = NULL;
+      client_send_response (pos);
+    }
+    else
+      client_send_response (pm);
+    return;
+  }
+}
+
+
+/**
+ * The @a pa was acknowledged, process the acknowledgement.
+ *
+ * @param pa the pending acknowledgement that was satisfied
+ * @param ack_delay artificial delay from cumulative acks created by the
+ * other peer
+ */
+static void
+handle_acknowledged (struct PendingAcknowledgement *pa,
+                     struct GNUNET_TIME_Relative ack_delay)
+{
+  struct GNUNET_TIME_Relative delay;
+
+  delay = GNUNET_TIME_absolute_get_duration (pa->transmission_time);
+  delay = GNUNET_TIME_relative_subtract (delay, ack_delay);
+  if (NULL != pa->queue && 1 == pa->num_send)
+    update_queue_performance (pa->queue, delay, pa->message_size);
+  if (NULL != pa->dvh && 1 == pa->num_send)
+    update_dvh_performance (pa->dvh, delay, pa->message_size);
+  if (NULL != pa->pm)
+    completed_pending_message (pa->pm);
+  free_pending_acknowledgement (pa);
+}
+
+
+/**
+ * Communicator gave us a reliability ack.  Check it is well-formed.
+ *
+ * @param cls a `struct CommunicatorMessageContext` (unused)
+ * @param ra the message that was received
+ * @return #GNUNET_Ok if @a ra is well-formed
+ */
+static int
+check_reliability_ack (void *cls,
+                       const struct TransportReliabilityAckMessage *ra)
+{
+  unsigned int n_acks;
+
+  (void) cls;
+  n_acks = (ntohs (ra->header.size) - sizeof(*ra))
+           / sizeof(struct TransportCummulativeAckPayloadP);
+  if (0 == n_acks)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  if ((ntohs (ra->header.size) - sizeof(*ra)) !=
+      n_acks * sizeof(struct TransportCummulativeAckPayloadP))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Communicator gave us a reliability ack.  Process the request.
+ *
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
+ * @param ra the message that was received
+ */
+static void
+handle_reliability_ack (void *cls,
+                        const struct TransportReliabilityAckMessage *ra)
+{
+  struct CommunicatorMessageContext *cmc = cls;
+  const struct TransportCummulativeAckPayloadP *ack;
+  unsigned int n_acks;
+  uint32_t ack_counter;
+
+  n_acks = (ntohs (ra->header.size) - sizeof(*ra))
+           / sizeof(struct TransportCummulativeAckPayloadP);
+  ack = (const struct TransportCummulativeAckPayloadP *) &ra[1];
+  for (unsigned int i = 0; i < n_acks; i++)
+  {
+    struct PendingAcknowledgement *pa =
+      GNUNET_CONTAINER_multiuuidmap_get (pending_acks, &ack[i].ack_uuid.value);
+    if (NULL == pa)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Received ACK from %s with UUID %s which is unknown to us!\n",
+                  GNUNET_i2s (&cmc->im.sender),
+                  GNUNET_uuid2s (&ack[i].ack_uuid.value));
+      GNUNET_STATISTICS_update (
+        GST_stats,
+        "# FRAGMENT_ACKS dropped, no matching pending message",
+        1,
+        GNUNET_NO);
+      continue;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received ACK from %s with UUID %s\n",
+                GNUNET_i2s (&cmc->im.sender),
+                GNUNET_uuid2s (&ack[i].ack_uuid.value));
+    handle_acknowledged (pa, GNUNET_TIME_relative_ntoh (ack[i].ack_delay));
+  }
+
+  ack_counter = htonl (ra->ack_counter);
+  (void) ack_counter;  /* silence compiler warning for now */
+  // FIXME-OPTIMIZE: track ACK losses based on ack_counter somewhere!
+  // (DV and/or Neighbour?)
+  finish_cmc_handling (cmc);
+}
+
+
+/**
+ * Communicator gave us a backchannel encapsulation.  Check the message.
+ *
+ * @param cls a `struct CommunicatorMessageContext`
+ * @param be the send message that was sent
+ * @return #GNUNET_YES if message is well-formed
+ */
+static int
+check_backchannel_encapsulation (
+  void *cls,
+  const struct TransportBackchannelEncapsulationMessage *be)
+{
+  uint16_t size = ntohs (be->header.size) - sizeof(*be);
+  const struct GNUNET_MessageHeader *inbox =
+    (const struct GNUNET_MessageHeader *) &be[1];
+  const char *is;
+  uint16_t isize;
+
+  (void) cls;
+  if (ntohs (inbox->size) >= size)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  isize = ntohs (inbox->size);
+  is = ((const char *) inbox) + isize;
+  size -= isize;
+  if ('\0' != is[size - 1])
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * Communicator gave us a backchannel encapsulation.  Process the request.
+ * (We are the destination of the backchannel here.)
+ *
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
+ * @param be the message that was received
+ */
+static void
+handle_backchannel_encapsulation (
+  void *cls,
+  const struct TransportBackchannelEncapsulationMessage *be)
+{
+  struct CommunicatorMessageContext *cmc = cls;
+  struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming *cbi;
+  struct GNUNET_MQ_Envelope *env;
+  struct TransportClient *tc;
+  const struct GNUNET_MessageHeader *inbox =
+    (const struct GNUNET_MessageHeader *) &be[1];
+  uint16_t isize = ntohs (inbox->size);
+  const char *target_communicator = ((const char *) inbox) + isize;
+  char *sender;
+  char *self;
+
+  GNUNET_asprintf (&sender,
+                   "%s",
+                   GNUNET_i2s (&cmc->im.sender));
+  GNUNET_asprintf (&self,
+                   "%s",
+                   GNUNET_i2s (&GST_my_identity));
+
+  /* Find client providing this communicator */
+  for (tc = clients_head; NULL != tc; tc = tc->next)
+    if ((CT_COMMUNICATOR == tc->type) &&
+        (0 ==
+         strcmp (tc->details.communicator.address_prefix, target_communicator)))
+      break;
+  if (NULL == tc)
+  {
+    char *stastr;
+
+    GNUNET_asprintf (
+      &stastr,
+      "# Backchannel message dropped: target communicator `%s' unknown",
+      target_communicator);
+    GNUNET_STATISTICS_update (GST_stats, stastr, 1, GNUNET_NO);
+    GNUNET_free (stastr);
+    finish_cmc_handling (cmc);
+    return;
+  }
+  /* Finally, deliver backchannel message to communicator */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Delivering backchannel message from %s to %s of type %u to %s\n",
+              sender,
+              self,
+              ntohs (inbox->type),
+              target_communicator);
+  env = GNUNET_MQ_msg_extra (
+    cbi,
+    isize,
+    GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL_INCOMING);
+  cbi->pid = cmc->im.sender;
+  memcpy (&cbi[1], inbox, isize);
+  GNUNET_MQ_send (tc->mq, env);
+  finish_cmc_handling (cmc);
+}
+
+
+/**
+ * Task called when we should check if any of the DV paths
+ * we have learned to a target are due for garbage collection.
+ *
+ * Collects stale paths, and possibly frees the entire DV
+ * entry if no paths are left. Otherwise re-schedules itself.
+ *
+ * @param cls a `struct DistanceVector`
+ */
+static void
+path_cleanup_cb (void *cls)
+{
+  struct DistanceVector *dv = cls;
+  struct DistanceVectorHop *pos;
+
+  dv->timeout_task = NULL;
+  while (NULL != (pos = dv->dv_head))
+  {
+    GNUNET_assert (dv == pos->dv);
+    if (GNUNET_TIME_absolute_get_remaining (pos->timeout).rel_value_us > 0)
+      break;
+    free_distance_vector_hop (pos);
+  }
+  if (NULL == pos)
+  {
+    free_dv_route (dv);
+    return;
+  }
+  dv->timeout_task =
+    GNUNET_SCHEDULER_add_at (pos->timeout, &path_cleanup_cb, dv);
+}
+
+
+static void
+send_msg_from_cache (struct VirtualLink *vl)
+{
+
+  const struct GNUNET_PeerIdentity target = vl->target;
+
+
+  if ((GNUNET_YES == is_ring_buffer_full) || (0 < ring_buffer_head))
+  {
+    struct RingBufferEntry *ring_buffer_copy[RING_BUFFER_SIZE];
+    unsigned int tail = GNUNET_YES == is_ring_buffer_full ? ring_buffer_head :
+                        0;
+    unsigned int head = GNUNET_YES == is_ring_buffer_full ? RING_BUFFER_SIZE :
+                        ring_buffer_head;
+    struct GNUNET_TRANSPORT_IncomingMessage im;
+    struct CommunicatorMessageContext *cmc;
+    struct RingBufferEntry *rbe;
+    struct GNUNET_MessageHeader *mh;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending from ring buffer, which has %u items\n",
+                head);
+
+    ring_buffer_head = 0;
+    for (unsigned int i = 0; i < head; i++)
+    {
+      rbe = ring_buffer[(i + tail) % RING_BUFFER_SIZE];
+      cmc = rbe->cmc;
+      mh = rbe->mh;
+
+      im = cmc->im;
+      // mh = cmc->mh;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Sending message of type %u to ring buffer target %s using vl target %s index %u\n",
+                  mh->type,
+                  GNUNET_i2s (&im.sender),
+                  GNUNET_i2s2 (&target),
+                  (i + tail) % RING_BUFFER_SIZE);
+      if (0 == GNUNET_memcmp (&target, &im.sender))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Finish handling message of type %u and size %u\n",
+                    (unsigned int) ntohs (mh->type),
+                    (unsigned int) ntohs (mh->size));
+        finish_handling_raw_message (vl, mh, cmc, GNUNET_NO);
+        GNUNET_free (mh);
+        GNUNET_free (rbe->cmc);
+        GNUNET_free (rbe);
+      }
+      else
+      {
+        ring_buffer_copy[ring_buffer_head] = rbe;
+        ring_buffer_head++;
+      }
+    }
+
+    if ((GNUNET_YES == is_ring_buffer_full) && (RING_BUFFER_SIZE - 1 >
+                                                ring_buffer_head))
+    {
+      is_ring_buffer_full = GNUNET_NO;
+    }
+
+    for (unsigned int i = 0; i < ring_buffer_head; i++)
+    {
+      ring_buffer[i] = ring_buffer_copy[i];
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "ring_buffer_copy[i]->mh->type for i %u %u\n",
+                  i,
+                  ring_buffer_copy[i]->mh->type);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "ring_buffer[i]->mh->type for i %u %u\n",
+                  i,
+                  ring_buffer[i]->mh->type);
+    }
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%u items still in ring buffer\n",
+                ring_buffer_head);
+  }
+
+  if ((GNUNET_YES == is_ring_buffer_dv_full) || (0 < ring_buffer_dv_head))
+  {
+    struct PendingMessage *ring_buffer_dv_copy[RING_BUFFER_SIZE];
+    struct PendingMessage *pm;
+    unsigned int tail = GNUNET_YES == is_ring_buffer_dv_full ?
+                        ring_buffer_dv_head :
+                        0;
+    unsigned int head = GNUNET_YES == is_ring_buffer_dv_full ?
+                        RING_BUFFER_SIZE :
+                        ring_buffer_dv_head;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending from ring buffer dv, which has %u items\n",
+                head);
+
+    ring_buffer_dv_head = 0;
+    for (unsigned int i = 0; i < head; i++)
+    {
+      pm = ring_buffer_dv[(i + tail) % RING_BUFFER_SIZE];
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Sending to ring buffer target %s using vl target %s\n",
+                  GNUNET_i2s (&pm->target),
+                  GNUNET_i2s2 (&target));
+      if (0 == GNUNET_memcmp (&target, &pm->target))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Adding PendingMessage to vl, checking transmission.\n");
+        pm->vl = vl;
+        GNUNET_CONTAINER_MDLL_insert (vl,
+                                      vl->pending_msg_head,
+                                      vl->pending_msg_tail,
+                                      pm);
+
+        check_vl_transmission (vl);
+      }
+      else
+      {
+        ring_buffer_dv_copy[ring_buffer_dv_head] = pm;
+        ring_buffer_dv_head++;
+      }
+    }
+
+    if (is_ring_buffer_dv_full && (RING_BUFFER_SIZE - 1 > ring_buffer_dv_head))
+    {
+      is_ring_buffer_dv_full = GNUNET_NO;
+    }
+
+    for (unsigned int i = 0; i < ring_buffer_dv_head; i++)
+      ring_buffer_dv[i] = ring_buffer_dv_copy[i];
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "%u items still in ring buffer dv.\n",
+                ring_buffer_dv_head);
+
+  }
+}
+
+
+/**
+ * The @a hop is a validated path to the respective target
+ * peer and we should tell core about it -- and schedule
+ * a job to revoke the state.
+ *
+ * @param hop a path to some peer that is the reason for activation
+ */
+static void
+activate_core_visible_dv_path (struct DistanceVectorHop *hop)
+{
+  struct DistanceVector *dv = hop->dv;
+  struct VirtualLink *vl;
+
+  vl = lookup_virtual_link (&dv->target);
+  if (NULL == vl)
+  {
+
+    vl = GNUNET_new (struct VirtualLink);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Creating new virtual link %p to %s using DV!\n",
+                vl,
+                GNUNET_i2s (&dv->target));
+    vl->confirmed = GNUNET_YES;
+    vl->message_uuid_ctr =
+      GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
+    vl->target = dv->target;
+    vl->core_recv_window = RECV_WINDOW_SIZE;
+    vl->available_fc_window_size = DEFAULT_WINDOW_SIZE;
+    vl->incoming_fc_window_size = DEFAULT_WINDOW_SIZE;
+    GNUNET_break (GNUNET_YES ==
+                  GNUNET_CONTAINER_multipeermap_put (
+                    links,
+                    &vl->target,
+                    vl,
+                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+    vl->dv = dv;
+    dv->vl = vl;
+    vl->visibility_task =
+      GNUNET_SCHEDULER_add_at (hop->path_valid_until, &check_link_down, vl);
+    consider_sending_fc (vl);
+    /* We lacked a confirmed connection to the target
+       before, so tell CORE about it (finally!) */
+    cores_send_connect_info (&dv->target);
+    send_msg_from_cache (vl);
+  }
+  else
+  {
+    /* Link was already up, remember dv is also now available and we are done */
+    vl->dv = dv;
+    dv->vl = vl;
+    if (GNUNET_NO == vl->confirmed)
+    {
+      vl->confirmed = GNUNET_YES;
+      vl->visibility_task =
+        GNUNET_SCHEDULER_add_at (hop->path_valid_until, &check_link_down, vl);
+      consider_sending_fc (vl);
+      /* We lacked a confirmed connection to the target
+         before, so tell CORE about it (finally!) */
+      cores_send_connect_info (&dv->target);
+      send_msg_from_cache (vl);
+    }
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Virtual link to %s could now also use DV!\n",
+                  GNUNET_i2s (&dv->target));
+  }
+}
+
+
+/**
+ * We have learned a @a path through the network to some other peer, add it to
+ * our DV data structure (returning #GNUNET_YES on success).
+ *
+ * We do not add paths if we have a sufficient number of shorter
+ * paths to this target already (returning #GNUNET_NO).
+ *
+ * We also do not add problematic paths, like those where we lack the first
+ * hop in our neighbour list (i.e. due to a topology change) or where some
+ * non-first hop is in our neighbour list (returning #GNUNET_SYSERR).
+ *
+ * @param path the path we learned, path[0] should be us,
+ *             and then path contains a valid path from us to
+ * `path[path_len-1]` path[1] should be a direct neighbour (we should check!)
+ * @param path_len number of entries on the @a path, at least three!
+ * @param network_latency how long does the message take from us to
+ * `path[path_len-1]`? set to "forever" if unknown
+ * @param path_valid_until how long is this path considered validated? Maybe
+ * be zero.
+ * @return #GNUNET_YES on success,
+ *         #GNUNET_NO if we have better path(s) to the target
+ *         #GNUNET_SYSERR if the path is useless and/or invalid
+ *                         (i.e. path[1] not a direct neighbour
+ *                        or path[i+1] is a direct neighbour for i>0)
+ */
+static int
+learn_dv_path (const struct GNUNET_PeerIdentity *path,
+               unsigned int path_len,
+               struct GNUNET_TIME_Relative network_latency,
+               struct GNUNET_TIME_Absolute path_valid_until)
+{
+  struct DistanceVectorHop *hop;
+  struct DistanceVector *dv;
+  struct Neighbour *next_hop;
+  unsigned int shorter_distance;
+
+  if (path_len < 3)
+  {
+    /* what a boring path! not allowed! */
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_assert (0 == GNUNET_memcmp (&GST_my_identity, &path[0]));
+  next_hop = lookup_neighbour (&path[1]);
+  if (NULL == next_hop)
+  {
+    /* next hop must be a neighbour, otherwise this whole thing is useless! */
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  for (unsigned int i = 2; i < path_len; i++)
+    if (NULL != lookup_neighbour (&path[i]))
+    {
+      /* Useless path: we have a direct connection to some hop
+         in the middle of the path, so this one is not even
+         terribly useful for redundancy */
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Path of %u hops useless: directly link to hop %u (%s)\n",
+                  path_len,
+                  i,
+                  GNUNET_i2s (&path[i]));
+      GNUNET_STATISTICS_update (GST_stats,
+                                "# Useless DV path ignored: hop is neighbour",
+                                1,
+                                GNUNET_NO);
+      return GNUNET_SYSERR;
+    }
+  dv = GNUNET_CONTAINER_multipeermap_get (dv_routes, &path[path_len - 1]);
+  if (NULL == dv)
+  {
+    dv = GNUNET_new (struct DistanceVector);
+    dv->target = path[path_len - 1];
+    dv->timeout_task = GNUNET_SCHEDULER_add_delayed (DV_PATH_VALIDITY_TIMEOUT,
+                                                     &path_cleanup_cb,
+                                                     dv);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multipeermap_put (
+                     dv_routes,
+                     &dv->target,
+                     dv,
+                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  }
+  /* Check if we have this path already! */
+  shorter_distance = 0;
+  for (struct DistanceVectorHop *pos = dv->dv_head; NULL != pos;
+       pos = pos->next_dv)
+  {
+    if (pos->distance < path_len - 3)
+      shorter_distance++;
+    /* Note that the distances in 'pos' excludes us (path[0]),
+       the next_hop (path[1]) and the target so we need to subtract three
+       and check next_hop explicitly */
+    if ((pos->distance == path_len - 3) && (pos->next_hop == next_hop))
+    {
+      int match = GNUNET_YES;
+
+      for (unsigned int i = 0; i < pos->distance; i++)
+      {
+        if (0 != GNUNET_memcmp (&pos->path[i], &path[i + 2]))
+        {
+          match = GNUNET_NO;
+          break;
+        }
+      }
+      if (GNUNET_YES == match)
+      {
+        struct GNUNET_TIME_Relative last_timeout;
+
+        /* Re-discovered known path, update timeout */
+        GNUNET_STATISTICS_update (GST_stats,
+                                  "# Known DV path refreshed",
+                                  1,
+                                  GNUNET_NO);
+        last_timeout = GNUNET_TIME_absolute_get_remaining (pos->timeout);
+        pos->timeout =
+          GNUNET_TIME_relative_to_absolute (DV_PATH_VALIDITY_TIMEOUT);
+        pos->path_valid_until =
+          GNUNET_TIME_absolute_max (pos->path_valid_until, path_valid_until);
+        GNUNET_CONTAINER_MDLL_remove (dv, dv->dv_head, dv->dv_tail, pos);
+        GNUNET_CONTAINER_MDLL_insert (dv, dv->dv_head, dv->dv_tail, pos);
+        if (0 <
+            GNUNET_TIME_absolute_get_remaining (path_valid_until).rel_value_us)
+          activate_core_visible_dv_path (pos);
+        if (last_timeout.rel_value_us <
+            GNUNET_TIME_relative_subtract (DV_PATH_VALIDITY_TIMEOUT,
+                                           DV_PATH_DISCOVERY_FREQUENCY)
+            .rel_value_us)
+        {
+          /* Some peer send DV learn messages too often, we are learning
+             the same path faster than it would be useful; do not forward! */
+          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                      "Rediscovered path too quickly, not forwarding further\n");
+          return GNUNET_NO;
+        }
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Refreshed known path to %s valid until %s, forwarding further\n",
+                    GNUNET_i2s (&dv->target),
+                    GNUNET_STRINGS_absolute_time_to_string (
+                      pos->path_valid_until));
+        return GNUNET_YES;
+      }
+    }
+  }
+  /* Count how many shorter paths we have (incl. direct
+     neighbours) before simply giving up on this one! */
+  if (shorter_distance >= MAX_DV_PATHS_TO_TARGET)
+  {
+    /* We have a shorter path already! */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Have many shorter DV paths %s, not forwarding further\n",
+                GNUNET_i2s (&dv->target));
+    return GNUNET_NO;
+  }
+  /* create new DV path entry */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Discovered new DV path to %s valid until %s\n",
+              GNUNET_i2s (&dv->target),
+              GNUNET_STRINGS_absolute_time_to_string (path_valid_until));
+  hop = GNUNET_malloc (sizeof(struct DistanceVectorHop)
+                       + sizeof(struct GNUNET_PeerIdentity) * (path_len - 3));
+  hop->next_hop = next_hop;
+  hop->dv = dv;
+  hop->path = (const struct GNUNET_PeerIdentity *) &hop[1];
+  memcpy (&hop[1],
+          &path[2],
+          sizeof(struct GNUNET_PeerIdentity) * (path_len - 3));
+  hop->timeout = GNUNET_TIME_relative_to_absolute (DV_PATH_VALIDITY_TIMEOUT);
+  hop->path_valid_until = path_valid_until;
+  hop->distance = path_len - 3;
+  hop->pd.aged_rtt = network_latency;
+  GNUNET_CONTAINER_MDLL_insert (dv, dv->dv_head, dv->dv_tail, hop);
+  GNUNET_CONTAINER_MDLL_insert (neighbour,
+                                next_hop->dv_head,
+                                next_hop->dv_tail,
+                                hop);
+  if (0 < GNUNET_TIME_absolute_get_remaining (path_valid_until).rel_value_us)
+    activate_core_visible_dv_path (hop);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Communicator gave us a DV learn message.  Check the message.
+ *
+ * @param cls a `struct CommunicatorMessageContext`
+ * @param dvl the send message that was sent
+ * @return #GNUNET_YES if message is well-formed
+ */
+static int
+check_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl)
+{
+  uint16_t size = ntohs (dvl->header.size);
+  uint16_t num_hops = ntohs (dvl->num_hops);
+  const struct DVPathEntryP *hops = (const struct DVPathEntryP *) &dvl[1];
+
+  (void) cls;
+  if (size != sizeof(*dvl) + num_hops * sizeof(struct DVPathEntryP))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  if (num_hops > MAX_DV_HOPS_ALLOWED)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  for (unsigned int i = 0; i < num_hops; i++)
+  {
+    if (0 == GNUNET_memcmp (&dvl->initiator, &hops[i].hop))
+    {
+      GNUNET_break_op (0);
+      return GNUNET_SYSERR;
+    }
+    if (0 == GNUNET_memcmp (&GST_my_identity, &hops[i].hop))
+    {
+      GNUNET_break_op (0);
+      return GNUNET_SYSERR;
+    }
+  }
+  return GNUNET_YES;
+}
+
+
+/**
+ * Build and forward a DV learn message to @a next_hop.
+ *
+ * @param next_hop peer to send the message to
+ * @param msg message received
+ * @param bi_history bitmask specifying hops on path that were bidirectional
+ * @param nhops length of the @a hops array
+ * @param hops path the message traversed so far
+ * @param in_time when did we receive the message, used to calculate network
+ * delay
+ */
+static void
+forward_dv_learn (const struct GNUNET_PeerIdentity *next_hop,
+                  const struct TransportDVLearnMessage *msg,
+                  uint16_t bi_history,
+                  uint16_t nhops,
+                  const struct DVPathEntryP *hops,
+                  struct GNUNET_TIME_Absolute in_time)
+{
+  struct Neighbour *n;
+  struct VirtualLink *vl;
+  struct DVPathEntryP *dhops;
+  char buf[sizeof(struct TransportDVLearnMessage)
+           + (nhops + 1) * sizeof(struct DVPathEntryP)] GNUNET_ALIGN;
+  struct TransportDVLearnMessage *fwd = (struct TransportDVLearnMessage *) buf;
+  struct GNUNET_TIME_Relative nnd;
+
+  /* compute message for forwarding */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Forwarding DV learn message originating from %s to %s\n",
+              GNUNET_i2s (&msg->initiator),
+              GNUNET_i2s2 (next_hop));
+  GNUNET_assert (nhops < MAX_DV_HOPS_ALLOWED);
+  fwd->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN);
+  fwd->header.size = htons (sizeof(struct TransportDVLearnMessage)
+                            + (nhops + 1) * sizeof(struct DVPathEntryP));
+  fwd->num_hops = htons (nhops + 1);
+  fwd->bidirectional = htons (bi_history);
+  nnd = GNUNET_TIME_relative_add (GNUNET_TIME_absolute_get_duration (in_time),
+                                  GNUNET_TIME_relative_ntoh (
+                                    msg->non_network_delay));
+  fwd->non_network_delay = GNUNET_TIME_relative_hton (nnd);
+  fwd->init_sig = msg->init_sig;
+  fwd->initiator = msg->initiator;
+  fwd->challenge = msg->challenge;
+  fwd->monotonic_time = msg->monotonic_time;
+  dhops = (struct DVPathEntryP *) &fwd[1];
+  GNUNET_memcpy (dhops, hops, sizeof(struct DVPathEntryP) * nhops);
+  dhops[nhops].hop = GST_my_identity;
+  {
+    struct DvHopPS dhp = {
+      .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP),
+      .purpose.size = htonl (sizeof(dhp)),
+      .pred = (0 == nhops) ? msg->initiator : dhops[nhops - 1].hop,
+      .succ = *next_hop,
+      .challenge = msg->challenge
+    };
+    GNUNET_CRYPTO_eddsa_sign (GST_my_private_key,
+                              &dhp,
+                              &dhops[nhops].hop_sig);
+  }
+  /*route_control_message_without_fc (next_hop,
+                                    &fwd->header,
+                                    RMO_UNCONFIRMED_ALLOWED);*/
+  vl = lookup_virtual_link (next_hop);
+  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
+  {
+    route_control_message_without_fc (vl,
+                                      &fwd->header,
+                                      RMO_UNCONFIRMED_ALLOWED);
+  }
+  else
+  {
+    /* Use route via neighbour */
+    n = lookup_neighbour (next_hop);
+    if (NULL != n)
+      route_via_neighbour (
+        n,
+        &fwd->header,
+        RMO_UNCONFIRMED_ALLOWED);
+  }
+}
+
+
+/**
+ * Check signature of type #GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR
+ *
+ * @param sender_monotonic_time monotonic time of the initiator
+ * @param init the signer
+ * @param challenge the challenge that was signed
+ * @param init_sig signature presumably by @a init
+ * @return #GNUNET_OK if the signature is valid
+ */
+static int
+validate_dv_initiator_signature (
+  struct GNUNET_TIME_AbsoluteNBO sender_monotonic_time,
+  const struct GNUNET_PeerIdentity *init,
+  const struct GNUNET_CRYPTO_ChallengeNonceP *challenge,
+  const struct GNUNET_CRYPTO_EddsaSignature *init_sig)
+{
+  struct DvInitPS ip = { .purpose.purpose = htonl (
+                           GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR),
+                         .purpose.size = htonl (sizeof(ip)),
+                         .monotonic_time = sender_monotonic_time,
+                         .challenge = *challenge };
+
+  if (
+    GNUNET_OK !=
+    GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR,
+                                &ip,
+                                init_sig,
+                                &init->public_key))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Closure for #dv_neighbour_selection and #dv_neighbour_transmission.
+ */
+struct NeighbourSelectionContext
+{
+  /**
+   * Original message we received.
+   */
+  const struct TransportDVLearnMessage *dvl;
+
+  /**
+   * The hops taken.
+   */
+  const struct DVPathEntryP *hops;
+
+  /**
+   * Time we received the message.
+   */
+  struct GNUNET_TIME_Absolute in_time;
+
+  /**
+   * Offsets of the selected peers.
+   */
+  uint32_t selections[MAX_DV_DISCOVERY_SELECTION];
+
+  /**
+   * Number of peers eligible for selection.
+   */
+  unsigned int num_eligible;
+
+  /**
+   * Number of peers that were selected for forwarding.
+   */
+  unsigned int num_selections;
+
+  /**
+   * Number of hops in @e hops
+   */
+  uint16_t nhops;
+
+  /**
+   * Bitmap of bidirectional connections encountered.
+   */
+  uint16_t bi_history;
+};
+
+
+/**
+ * Function called for each neighbour during #handle_dv_learn.
+ *
+ * @param cls a `struct NeighbourSelectionContext *`
+ * @param pid identity of the peer
+ * @param value a `struct Neighbour`
+ * @return #GNUNET_YES (always)
+ */
+static int
+dv_neighbour_selection (void *cls,
+                        const struct GNUNET_PeerIdentity *pid,
+                        void *value)
+{
+  struct NeighbourSelectionContext *nsc = cls;
+
+  (void) value;
+  if (0 == GNUNET_memcmp (pid, &nsc->dvl->initiator))
+    return GNUNET_YES; /* skip initiator */
+  for (unsigned int i = 0; i < nsc->nhops; i++)
+    if (0 == GNUNET_memcmp (pid, &nsc->hops[i].hop))
+      return GNUNET_YES;
+  /* skip peers on path */
+  nsc->num_eligible++;
+  return GNUNET_YES;
+}
+
+
+/**
+ * Function called for each neighbour during #handle_dv_learn.
+ * We call #forward_dv_learn() on the neighbour(s) selected
+ * during #dv_neighbour_selection().
+ *
+ * @param cls a `struct NeighbourSelectionContext *`
+ * @param pid identity of the peer
+ * @param value a `struct Neighbour`
+ * @return #GNUNET_YES (always)
+ */
+static int
+dv_neighbour_transmission (void *cls,
+                           const struct GNUNET_PeerIdentity *pid,
+                           void *value)
+{
+  struct NeighbourSelectionContext *nsc = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "transmission %s\n",
+              GNUNET_i2s (pid));
+  (void) value;
+  if (0 == GNUNET_memcmp (pid, &nsc->dvl->initiator))
+    return GNUNET_YES; /* skip initiator */
+  for (unsigned int i = 0; i < nsc->nhops; i++)
+    if (0 == GNUNET_memcmp (pid, &nsc->hops[i].hop))
+      return GNUNET_YES;
+  /* skip peers on path */
+  for (unsigned int i = 0; i < nsc->num_selections; i++)
+  {
+    if (nsc->selections[i] == nsc->num_eligible)
+    {
+      forward_dv_learn (pid,
+                        nsc->dvl,
+                        nsc->bi_history,
+                        nsc->nhops,
+                        nsc->hops,
+                        nsc->in_time);
+      break;
+    }
+  }
+  nsc->num_eligible++;
+  return GNUNET_YES;
+}
+
+
+/**
+ * Computes the number of neighbours we should forward a DVInit
+ * message to given that it has so far taken @a hops_taken hops
+ * though the network and that the number of neighbours we have
+ * in total is @a neighbour_count, out of which @a eligible_count
+ * are not yet on the path.
+ *
+ * NOTE: technically we might want to include NSE in the formula to
+ * get a better grip on the overall network size. However, for now
+ * using NSE here would create a dependency issue in the build system.
+ * => Left for later, hardcoded to 50 for now.
+ *
+ * The goal of the fomula is that we want to reach a total of LOG(NSE)
+ * peers via DV (`target_total`).  We want the reach to be spread out
+ * over various distances to the origin, with a bias towards shorter
+ * distances.
+ *
+ * We make the strong assumption that the network topology looks
+ * "similar" at other hops, in particular the @a neighbour_count
+ * should be comparable at other hops.
+ *
+ * If the local neighbourhood is densely connected, we expect that @a
+ * eligible_count is close to @a neighbour_count minus @a hops_taken
+ * as a lot of the path is already known. In that case, we should
+ * forward to few(er) peers to try to find a path out of the
+ * neighbourhood. OTOH, if @a eligible_count is close to @a
+ * neighbour_count, we should forward to many peers as we are either
+ * still close to the origin (i.e.  @a hops_taken is small) or because
+ * we managed to get beyond a local cluster.  We express this as
+ * the `boost_factor` using the square of the fraction of eligible
+ * neighbours (so if only 50% are eligible, we boost by 1/4, but if
+ * 99% are eligible, the 'boost' will be almost 1).
+ *
+ * Second, the more hops we have taken, the larger the problem of an
+ * exponential traffic explosion gets.  So we take the `target_total`,
+ * and compute our degree such that at each distance d 2^{-d} peers
+ * are selected (corrected by the `boost_factor`).
+ *
+ * @param hops_taken number of hops DVInit has travelled so far
+ * @param neighbour_count number of neighbours we have in total
+ * @param eligible_count number of neighbours we could in
+ *        theory forward to
+ */
+static unsigned int
+calculate_fork_degree (unsigned int hops_taken,
+                       unsigned int neighbour_count,
+                       unsigned int eligible_count)
+{
+  double target_total = 50.0; /* FIXME: use LOG(NSE)? */
+  double eligible_ratio =
+    ((double) eligible_count) / ((double) neighbour_count);
+  double boost_factor = eligible_ratio * eligible_ratio;
+  unsigned int rnd;
+  double left;
+
+  if (hops_taken >= 64)
+  {
+    GNUNET_break (0);
+    return 0;   /* precaution given bitshift below */
+  }
+  for (unsigned int i = 1; i < hops_taken; i++)
+  {
+    /* For each hop, subtract the expected number of targets
+       reached at distance d (so what remains divided by 2^d) */
+    target_total -= (target_total * boost_factor / (1LLU << i));
+  }
+  rnd =
+    (unsigned int) floor (target_total * boost_factor / (1LLU << hops_taken));
+  /* round up or down probabilistically depending on how close we were
+     when floor()ing to rnd */
+  left = target_total - (double) rnd;
+  if (UINT32_MAX * left >
+      GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX))
+    rnd++; /* round up */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Forwarding DV learn message of %u hops %u(/%u/%u) times\n",
+              hops_taken,
+              rnd,
+              eligible_count,
+              neighbour_count);
+  return rnd;
+}
+
+
+/**
+ * Function called when peerstore is done storing a DV monotonic time.
+ *
+ * @param cls a `struct Neighbour`
+ * @param success #GNUNET_YES if peerstore was successful
+ */
+static void
+neighbour_store_dvmono_cb (void *cls, int success)
+{
+  struct Neighbour *n = cls;
+
+  n->sc = NULL;
+  if (GNUNET_YES != success)
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to store other peer's monotonic time in peerstore!\n");
+}
+
+
+/**
+ * Communicator gave us a DV learn message.  Process the request.
+ *
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
+ * @param dvl the message that was received
+ */
+static void
+handle_dv_learn (void *cls, const struct TransportDVLearnMessage *dvl)
+{
+  struct CommunicatorMessageContext *cmc = cls;
+  enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc;
+  int bi_hop;
+  uint16_t nhops;
+  uint16_t bi_history;
+  const struct DVPathEntryP *hops;
+  int do_fwd;
+  int did_initiator;
+  struct GNUNET_TIME_Absolute in_time;
+  struct Neighbour *n;
+
+  nhops = ntohs (dvl->num_hops);  /* 0 = sender is initiator */
+  bi_history = ntohs (dvl->bidirectional);
+  hops = (const struct DVPathEntryP *) &dvl[1];
+  if (0 == nhops)
+  {
+    /* sanity check */
+    if (0 != GNUNET_memcmp (&dvl->initiator, &cmc->im.sender))
+    {
+      GNUNET_break (0);
+      finish_cmc_handling (cmc);
+      return;
+    }
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "handle dv learn message last hop %s\n",
+                GNUNET_i2s (&hops[nhops - 1].hop));
+    /* sanity check */
+    if (0 != GNUNET_memcmp (&hops[nhops - 1].hop, &cmc->im.sender))
+    {
+      GNUNET_break (0);
+      finish_cmc_handling (cmc);
+      return;
+    }
+  }
+
+  GNUNET_assert (CT_COMMUNICATOR == cmc->tc->type);
+  cc = cmc->tc->details.communicator.cc;
+  bi_hop = (GNUNET_TRANSPORT_CC_RELIABLE ==
+            cc); // FIXME: add bi-directional flag to cc?
+  in_time = GNUNET_TIME_absolute_get ();
+
+  /* continue communicator here, everything else can happen asynchronous! */
+  finish_cmc_handling (cmc);
+
+  n = lookup_neighbour (&dvl->initiator);
+  if (NULL != n)
+  {
+    if ((n->dv_monotime_available == GNUNET_YES) &&
+        (GNUNET_TIME_absolute_ntoh (dvl->monotonic_time).abs_value_us <
+         n->last_dv_learn_monotime.abs_value_us))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "DV learn from %s discarded due to time travel",
+                  GNUNET_i2s (&dvl->initiator));
+      GNUNET_STATISTICS_update (GST_stats,
+                                "# DV learn discarded due to time travel",
+                                1,
+                                GNUNET_NO);
+      return;
+    }
+    if (GNUNET_OK != validate_dv_initiator_signature (dvl->monotonic_time,
+                                                      &dvl->initiator,
+                                                      &dvl->challenge,
+                                                      &dvl->init_sig))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "DV learn signature from %s invalid\n",
+                  GNUNET_i2s (&dvl->initiator));
+      GNUNET_break_op (0);
+      return;
+    }
+    n->last_dv_learn_monotime = GNUNET_TIME_absolute_ntoh (dvl->monotonic_time);
+    if (GNUNET_YES == n->dv_monotime_available)
+    {
+      if (NULL != n->sc)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "store cancel\n");
+        GNUNET_PEERSTORE_store_cancel (n->sc);
+      }
+      n->sc =
+        GNUNET_PEERSTORE_store (peerstore,
+                                "transport",
+                                &dvl->initiator,
+                                GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME,
+                                &dvl->monotonic_time,
+                                sizeof(dvl->monotonic_time),
+                                GNUNET_TIME_UNIT_FOREVER_ABS,
+                                GNUNET_PEERSTORE_STOREOPTION_REPLACE,
+                                &neighbour_store_dvmono_cb,
+                                n);
+    }
+  }
+  /* OPTIMIZE-FIXME: asynchronously (!) verify signatures!,
+     If signature verification load too high, implement random drop strategy */
+  for (unsigned int i = 0; i < nhops; i++)
+  {
+    struct DvHopPS dhp = { .purpose.purpose =
+                             htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP),
+                           .purpose.size = htonl (sizeof(dhp)),
+                           .pred = (0 == i) ? dvl->initiator : hops[i - 1].hop,
+                           .succ = (nhops == i + 1) ? GST_my_identity
+                                   : hops[i + 1].hop,
+                           .challenge = dvl->challenge };
+
+    if (GNUNET_OK !=
+        GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_HOP,
+                                    &dhp,
+                                    &hops[i].hop_sig,
+                                    &hops[i].hop.public_key))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "DV learn from %s signature of hop %u invalid\n",
+                  GNUNET_i2s (&dvl->initiator),
+                  i);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "signature of hop %s invalid\n",
+                  GNUNET_i2s (&hops[i].hop));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "pred %s\n",
+                  GNUNET_i2s (&dhp.pred));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "succ %s\n",
+                  GNUNET_i2s (&dhp.succ));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "hash %s\n",
+                  GNUNET_sh2s (&dhp.challenge.value));
+      GNUNET_break_op (0);
+      return;
+    }
+  }
+  if (GNUNET_EXTRA_LOGGING > 0)
+  {
+    char *path;
+
+    path = GNUNET_strdup (GNUNET_i2s (&dvl->initiator));
+    for (unsigned int i = 0; i < nhops; i++)
+    {
+      char *tmp;
+
+      GNUNET_asprintf (&tmp,
+                       "%s%s%s",
+                       path,
+                       (bi_history & (1 << (nhops - i))) ? "<->" : "-->",
+                       GNUNET_i2s (&hops[i].hop));
+      GNUNET_free (path);
+      path = tmp;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received DVInit via %s%s%s\n",
+                path,
+                bi_hop ? "<->" : "-->",
+                GNUNET_i2s (&GST_my_identity));
+    GNUNET_free (path);
+  }
+  do_fwd = GNUNET_YES;
+  if (0 == GNUNET_memcmp (&GST_my_identity, &dvl->initiator))
+  {
+    struct GNUNET_PeerIdentity path[nhops + 1];
+    struct GNUNET_TIME_Relative host_latency_sum;
+    struct GNUNET_TIME_Relative latency;
+    struct GNUNET_TIME_Relative network_latency;
+
+    /* We initiated this, learn the forward path! */
+    path[0] = GST_my_identity;
+    path[1] = hops[0].hop;
+    host_latency_sum = GNUNET_TIME_relative_ntoh (dvl->non_network_delay);
+
+    // Need also something to lookup initiation time
+    // to compute RTT! -> add RTT argument here?
+    latency = GNUNET_TIME_absolute_get_duration (GNUNET_TIME_absolute_ntoh (
+                                                   dvl->monotonic_time));
+    GNUNET_assert (latency.rel_value_us >= host_latency_sum.rel_value_us);
+    // latency = GNUNET_TIME_UNIT_FOREVER_REL;   // FIXME: initialize properly
+    // (based on dvl->challenge, we can identify time of origin!)
+
+    network_latency = GNUNET_TIME_relative_subtract (latency, host_latency_sum);
+    /* assumption: latency on all links is the same */
+    network_latency = GNUNET_TIME_relative_divide (network_latency, nhops);
+
+    for (unsigned int i = 2; i <= nhops; i++)
+    {
+      struct GNUNET_TIME_Relative ilat;
+
+      /* assumption: linear latency increase per hop */
+      ilat = GNUNET_TIME_relative_multiply (network_latency, i);
+      path[i] = hops[i - 1].hop;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Learned path with %u hops to %s with latency %s\n",
+                  i,
+                  GNUNET_i2s (&path[i]),
+                  GNUNET_STRINGS_relative_time_to_string (ilat, GNUNET_YES));
+      learn_dv_path (path,
+                     i + 1,
+                     ilat,
+                     GNUNET_TIME_relative_to_absolute (
+                       ADDRESS_VALIDATION_LIFETIME));
+    }
+    /* as we initiated, do not forward again (would be circular!) */
+    do_fwd = GNUNET_NO;
+    return;
+  }
+  if (bi_hop)
+  {
+    /* last hop was bi-directional, we could learn something here! */
+    struct GNUNET_PeerIdentity path[nhops + 2];
+
+    path[0] = GST_my_identity;
+    path[1] = hops[nhops - 1].hop;   /* direct neighbour == predecessor! */
+    for (unsigned int i = 0; i < nhops; i++)
+    {
+      int iret;
+
+      if (0 == (bi_history & (1 << i)))
+        break;     /* i-th hop not bi-directional, stop learning! */
+      if (i == nhops - 1)
+      {
+        path[i + 2] = dvl->initiator;
+      }
+      else
+      {
+        path[i + 2] = hops[nhops - i - 2].hop;
+      }
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Learned inverse path with %u hops to %s\n",
+                  i + 2,
+                  GNUNET_i2s (&path[i + 2]));
+      iret = learn_dv_path (path,
+                            i + 3,
+                            GNUNET_TIME_UNIT_FOREVER_REL,
+                            GNUNET_TIME_relative_to_absolute (
+                              ADDRESS_VALIDATION_LIFETIME));
+      if (GNUNET_SYSERR == iret)
+      {
+        /* path invalid or too long to be interesting for US, thus should also
+           not be interesting to our neighbours, cut path when forwarding to
+           'i' hops, except of course for the one that goes back to the
+           initiator */
+        GNUNET_STATISTICS_update (GST_stats,
+                                  "# DV learn not forwarded due invalidity of path",
+                                  1,
+                                  GNUNET_NO);
+        do_fwd = GNUNET_NO;
+        break;
+      }
+      if ((GNUNET_NO == iret) && (nhops == i + 1))
+      {
+        /* we have better paths, and this is the longest target,
+           so there cannot be anything interesting later */
+        GNUNET_STATISTICS_update (GST_stats,
+                                  "# DV learn not forwarded, got better paths",
+                                  1,
+                                  GNUNET_NO);
+        do_fwd = GNUNET_NO;
+        break;
+      }
+    }
+  }
+  if (MAX_DV_HOPS_ALLOWED == nhops)
+  {
+    /* At limit, we're out of here! */
+    return;
+  }
+
+  /* Forward to initiator, if path non-trivial and possible */
+  bi_history = (bi_history << 1) | (bi_hop ? 1 : 0);
+  did_initiator = GNUNET_NO;
+  if ((1 <= nhops) &&
+      (GNUNET_YES ==
+       GNUNET_CONTAINER_multipeermap_contains (neighbours, &dvl->initiator)))
+  {
+    /* send back to origin! */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending DVL back to initiator %s\n",
+                GNUNET_i2s (&dvl->initiator));
+    forward_dv_learn (&dvl->initiator, dvl, bi_history, nhops, hops, in_time);
+    did_initiator = GNUNET_YES;
+  }
+  /* We forward under two conditions: either we still learned something
+     ourselves (do_fwd), or the path was darn short and thus the initiator is
+     likely to still be very interested in this (and we did NOT already
+     send it back to the initiator) */
+  if ((do_fwd) || ((nhops < MIN_DV_PATH_LENGTH_FOR_INITIATOR) &&
+                   (GNUNET_NO == did_initiator)))
+  {
+    /* Pick random neighbours that are not yet on the path */
+    struct NeighbourSelectionContext nsc;
+    unsigned int n_cnt;
+
+    n_cnt = GNUNET_CONTAINER_multipeermap_size (neighbours);
+    nsc.nhops = nhops;
+    nsc.dvl = dvl;
+    nsc.bi_history = bi_history;
+    nsc.hops = hops;
+    nsc.in_time = in_time;
+    nsc.num_eligible = 0;
+    GNUNET_CONTAINER_multipeermap_iterate (neighbours,
+                                           &dv_neighbour_selection,
+                                           &nsc);
+    if (0 == nsc.num_eligible)
+      return;   /* done here, cannot forward to anyone else */
+    nsc.num_selections = calculate_fork_degree (nhops, n_cnt, nsc.num_eligible);
+    nsc.num_selections =
+      GNUNET_MIN (MAX_DV_DISCOVERY_SELECTION, nsc.num_selections);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Forwarding DVL to %u other peers\n",
+                nsc.num_selections);
+    for (unsigned int i = 0; i < nsc.num_selections; i++)
+      nsc.selections[i] =
+        (nsc.num_selections == n_cnt)
+        ? i   /* all were selected, avoid collisions by chance */
+        : GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, n_cnt);
+    nsc.num_eligible = 0;
+    GNUNET_CONTAINER_multipeermap_iterate (neighbours,
+                                           &dv_neighbour_transmission,
+                                           &nsc);
+  }
+}
+
+
+/**
+ * Communicator gave us a DV box.  Check the message.
+ *
+ * @param cls a `struct CommunicatorMessageContext`
+ * @param dvb the send message that was sent
+ * @return #GNUNET_YES if message is well-formed
+ */
+static int
+check_dv_box (void *cls, const struct TransportDVBoxMessage *dvb)
+{
+  uint16_t size = ntohs (dvb->header.size);
+  uint16_t num_hops = ntohs (dvb->num_hops);
+  const struct GNUNET_PeerIdentity *hops =
+    (const struct GNUNET_PeerIdentity *) &dvb[1];
+
+  (void) cls;
+  if (size < sizeof(*dvb) + num_hops * sizeof(struct GNUNET_PeerIdentity)
+      + sizeof(struct GNUNET_MessageHeader))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  /* This peer must not be on the path */
+  for (unsigned int i = 0; i < num_hops; i++)
+    if (0 == GNUNET_memcmp (&hops[i], &GST_my_identity))
+    {
+      GNUNET_break_op (0);
+      return GNUNET_SYSERR;
+    }
+  return GNUNET_YES;
+}
+
+
+/**
+ * Create a DV Box message and queue it for transmission to
+ * @a next_hop.
+ *
+ * @param next_hop peer to receive the message next
+ * @param total_hops how many hops did the message take so far
+ * @param num_hops length of the @a hops array
+ * @param origin origin of the message
+ * @param hops next peer(s) to the destination, including destination
+ * @param payload payload of the box
+ * @param payload_size number of bytes in @a payload
+ */
+static void
+forward_dv_box (struct Neighbour *next_hop,
+                struct TransportDVBoxMessage *hdr,
+                uint16_t total_hops,
+                uint16_t num_hops,
+                const struct GNUNET_PeerIdentity *hops,
+                const void *enc_payload,
+                uint16_t enc_payload_size)
+{
+  struct VirtualLink *vl = next_hop->vl;
+  struct PendingMessage *pm;
+  size_t msg_size = sizeof(struct TransportDVBoxMessage)
+                    + num_hops * sizeof(struct GNUNET_PeerIdentity)
+                    + enc_payload_size;
+  char *buf;
+  char msg_buf[msg_size] GNUNET_ALIGN;
+  struct GNUNET_PeerIdentity *dhops;
+
+  hdr->num_hops = htons (num_hops);
+  hdr->total_hops = htons (total_hops);
+  hdr->header.size = htons (msg_size);
+  memcpy (msg_buf, hdr, sizeof(*hdr));
+  dhops = (struct GNUNET_PeerIdentity *) &msg_buf[sizeof(struct
+                                                         TransportDVBoxMessage)];
+  memcpy (dhops, hops, num_hops * sizeof(struct GNUNET_PeerIdentity));
+  memcpy (&dhops[num_hops], enc_payload, enc_payload_size);
+
+  if (GNUNET_YES == ntohs (hdr->without_fc))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Forwarding control message (payload size %u) in DV Box to next hop %s (%u/%u) \n",
+                enc_payload_size,
+                GNUNET_i2s (&next_hop->pid),
+                (unsigned int) num_hops,
+                (unsigned int) total_hops);
+    route_via_neighbour (next_hop, (const struct
+                                    GNUNET_MessageHeader *) msg_buf,
+                         RMO_ANYTHING_GOES);
+  }
+  else
+  {
+    pm = GNUNET_malloc (sizeof(struct PendingMessage) + msg_size);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "2 created pm %p storing vl %p \n",
+                pm,
+                vl);
+    pm->pmt = PMT_DV_BOX;
+    pm->vl = vl;
+    pm->target = next_hop->pid;
+    pm->timeout = GNUNET_TIME_relative_to_absolute (DV_FORWARD_TIMEOUT);
+    pm->logging_uuid = logging_uuid_gen++;
+    pm->prefs = GNUNET_MQ_PRIO_BACKGROUND;
+    pm->bytes_msg = msg_size;
+    buf = (char *) &pm[1];
+    memcpy (buf, msg_buf, msg_size);
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Created pending message %" PRIu64
+                " for DV Box with next hop %s (%u/%u)\n",
+                pm->logging_uuid,
+                GNUNET_i2s (&next_hop->pid),
+                (unsigned int) num_hops,
+                (unsigned int) total_hops);
+
+    if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
+    {
+      GNUNET_CONTAINER_MDLL_insert (vl,
+                                    vl->pending_msg_head,
+                                    vl->pending_msg_tail,
+                                    pm);
+
+      check_vl_transmission (vl);
+    }
+    else
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "The virtual link is not ready for forwarding a DV Box with payload, storing PendingMessage in ring buffer.\n");
+
+      if (NULL != ring_buffer_dv[ring_buffer_dv_head])
+      {
+        struct PendingMessage *pm_old = ring_buffer_dv[ring_buffer_dv_head];
+
+        GNUNET_free (pm_old);
+      }
+      ring_buffer_dv[ring_buffer_dv_head] = pm;
+      if (RING_BUFFER_SIZE - 1 == ring_buffer_dv_head)
+      {
+        ring_buffer_dv_head = 0;
+        is_ring_buffer_dv_full = GNUNET_YES;
+      }
+      else
+        ring_buffer_dv_head++;
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "%u items stored in DV ring buffer\n",
+                  GNUNET_YES == is_ring_buffer_dv_full ? RING_BUFFER_SIZE :
+                  ring_buffer_dv_head);
+    }
+  }
+}
+
+
+/**
+ * Free data structures associated with @a b.
+ *
+ * @param b data structure to release
+ */
+static void
+free_backtalker (struct Backtalker *b)
+{
+  if (NULL != b->get)
+  {
+    GNUNET_PEERSTORE_iteration_stop (b->get);
+    b->get = NULL;
+    GNUNET_assert (NULL != b->cmc);
+    finish_cmc_handling (b->cmc);
+    b->cmc = NULL;
+  }
+  if (NULL != b->task)
+  {
+    GNUNET_SCHEDULER_cancel (b->task);
+    b->task = NULL;
+  }
+  if (NULL != b->sc)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "store cancel\n");
+    GNUNET_PEERSTORE_store_cancel (b->sc);
+    b->sc = NULL;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Removing backtalker for %s\n",
+              GNUNET_i2s (&b->pid));
+  GNUNET_assert (
+    GNUNET_YES ==
+    GNUNET_CONTAINER_multipeermap_remove (backtalkers, &b->pid, b));
+  GNUNET_free (b);
+}
+
+
+/**
+ * Callback to free backtalker records.
+ *
+ * @param cls NULL
+ * @param pid unused
+ * @param value a `struct Backtalker`
+ * @return #GNUNET_OK (always)
+ */
+static int
+free_backtalker_cb (void *cls,
+                    const struct GNUNET_PeerIdentity *pid,
+                    void *value)
+{
+  struct Backtalker *b = value;
+
+  (void) cls;
+  (void) pid;
+  free_backtalker (b);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function called when it is time to clean up a backtalker.
+ *
+ * @param cls a `struct Backtalker`
+ */
+static void
+backtalker_timeout_cb (void *cls)
+{
+  struct Backtalker *b = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "backtalker timeout.\n");
+  b->task = NULL;
+  if (0 != GNUNET_TIME_absolute_get_remaining (b->timeout).rel_value_us)
+  {
+    b->task = GNUNET_SCHEDULER_add_at (b->timeout, &backtalker_timeout_cb, b);
+    return;
+  }
+  GNUNET_assert (NULL == b->sc);
+  free_backtalker (b);
+}
+
+
+/**
+ * Function called with the monotonic time of a backtalker
+ * by PEERSTORE. Updates the time and continues processing.
+ *
+ * @param cls a `struct Backtalker`
+ * @param record the information found, NULL for the last call
+ * @param emsg error message
+ */
+static void
+backtalker_monotime_cb (void *cls,
+                        const struct GNUNET_PEERSTORE_Record *record,
+                        const char *emsg)
+{
+  struct Backtalker *b = cls;
+  struct GNUNET_TIME_AbsoluteNBO *mtbe;
+  struct GNUNET_TIME_Absolute mt;
+
+  (void) emsg;
+  if (NULL == record)
+  {
+    /* we're done with #backtalker_monotime_cb() invocations,
+       continue normal processing */
+    b->get = NULL;
+    GNUNET_assert (NULL != b->cmc);
+    b->cmc->mh = (const struct GNUNET_MessageHeader *) &b[1];
+    if (0 != b->body_size)
+      demultiplex_with_cmc (b->cmc);
+    else
+      finish_cmc_handling (b->cmc);
+    b->cmc = NULL;
+    return;
+  }
+  if (sizeof(*mtbe) != record->value_size)
+  {
+    GNUNET_PEERSTORE_iteration_next (b->get, 1);
+    GNUNET_break (0);
+    return;
+  }
+  mtbe = record->value;
+  mt = GNUNET_TIME_absolute_ntoh (*mtbe);
+  if (mt.abs_value_us > b->monotonic_time.abs_value_us)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Backtalker message from %s dropped, monotime in the past\n",
+                GNUNET_i2s (&b->pid));
+    GNUNET_STATISTICS_update (
+      GST_stats,
+      "# Backchannel messages dropped: monotonic time not increasing",
+      1,
+      GNUNET_NO);
+    b->monotonic_time = mt;
+    /* Setting body_size to 0 prevents call to #forward_backchannel_payload()
+     */
+    b->body_size = 0;
+  }
+  GNUNET_PEERSTORE_iteration_next (b->get, 1);
+}
+
+
+/**
+ * Function called by PEERSTORE when the store operation of
+ * a backtalker's monotonic time is complete.
+ *
+ * @param cls the `struct Backtalker`
+ * @param success #GNUNET_OK on success
+ */
+static void
+backtalker_monotime_store_cb (void *cls, int success)
+{
+  struct Backtalker *b = cls;
+
+  if (GNUNET_OK != success)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to store backtalker's monotonic time in PEERSTORE!\n");
+  }
+  b->sc = NULL;
+  if (NULL != b->task)
+  {
+    GNUNET_SCHEDULER_cancel (b->task);
+    b->task = NULL;
+  }
+  b->task = GNUNET_SCHEDULER_add_at (b->timeout, &backtalker_timeout_cb, b);
+}
+
+
+/**
+ * The backtalker @a b monotonic time changed. Update PEERSTORE.
+ *
+ * @param b a backtalker with updated monotonic time
+ */
+static void
+update_backtalker_monotime (struct Backtalker *b)
+{
+  struct GNUNET_TIME_AbsoluteNBO mtbe;
+
+  if (NULL != b->sc)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "store cancel before store with sc %p\n",
+                b->sc);
+    /*GNUNET_PEERSTORE_store_cancel (b->sc);
+      b->sc = NULL;*/
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "store cancel before store with sc %p is null\n",
+                b->sc);
+  }
+  else
+  {
+    GNUNET_SCHEDULER_cancel (b->task);
+    b->task = NULL;
+  }
+  mtbe = GNUNET_TIME_absolute_hton (b->monotonic_time);
+  b->sc =
+    GNUNET_PEERSTORE_store (peerstore,
+                            "transport",
+                            &b->pid,
+                            GNUNET_PEERSTORE_TRANSPORT_BACKCHANNEL_MONOTIME,
+                            &mtbe,
+                            sizeof(mtbe),
+                            GNUNET_TIME_UNIT_FOREVER_ABS,
+                            GNUNET_PEERSTORE_STOREOPTION_REPLACE,
+                            &backtalker_monotime_store_cb,
+                            b);
+}
+
+
+/**
+ * Communicator gave us a DV box.  Process the request.
+ *
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
+ * @param dvb the message that was received
+ */
+static void
+handle_dv_box (void *cls, const struct TransportDVBoxMessage *dvb)
+{
+  struct CommunicatorMessageContext *cmc = cls;
+  uint16_t size = ntohs (dvb->header.size) - sizeof(*dvb);
+  uint16_t num_hops = ntohs (dvb->num_hops);
+  const struct GNUNET_PeerIdentity *hops =
+    (const struct GNUNET_PeerIdentity *) &dvb[1];
+  const char *enc_payload = (const char *) &hops[num_hops];
+  uint16_t enc_payload_size =
+    size - (num_hops * sizeof(struct GNUNET_PeerIdentity));
+  struct DVKeyState key;
+  struct GNUNET_HashCode hmac;
+  const char *hdr;
+  size_t hdr_len;
+
+  if (GNUNET_EXTRA_LOGGING > 0)
+  {
+    char *path;
+
+    path = GNUNET_strdup (GNUNET_i2s (&GST_my_identity));
+    for (unsigned int i = 0; i < num_hops; i++)
+    {
+      char *tmp;
+
+      GNUNET_asprintf (&tmp, "%s->%s", path, GNUNET_i2s (&hops[i]));
+      GNUNET_free (path);
+      path = tmp;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received DVBox with remaining path %s\n",
+                path);
+    GNUNET_free (path);
+  }
+
+  if (num_hops > 0)
+  {
+    /* We're trying from the end of the hops array, as we may be
+       able to find a shortcut unknown to the origin that way */
+    for (int i = num_hops - 1; i >= 0; i--)
+    {
+      struct Neighbour *n;
+
+      if (0 == GNUNET_memcmp (&hops[i], &GST_my_identity))
+      {
+        GNUNET_break_op (0);
+        finish_cmc_handling (cmc);
+        return;
+      }
+      n = lookup_neighbour (&hops[i]);
+      if (NULL == n)
+        continue;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Skipping %u/%u hops ahead while routing DV Box\n",
+                  i,
+                  num_hops);
+
+      forward_dv_box (n,
+                      (struct TransportDVBoxMessage *) dvb,
+                      ntohs (dvb->total_hops) + 1,
+                      num_hops - i - 1,    /* number of hops left */
+                      &hops[i + 1],    /* remaining hops */
+                      enc_payload,
+                      enc_payload_size);
+      GNUNET_STATISTICS_update (GST_stats,
+                                "# DV hops skipped routing boxes",
+                                i,
+                                GNUNET_NO);
+      GNUNET_STATISTICS_update (GST_stats,
+                                "# DV boxes routed (total)",
+                                1,
+                                GNUNET_NO);
+      finish_cmc_handling (cmc);
+      return;
+    }
+    /* Woopsie, next hop not in neighbours, drop! */
+    GNUNET_STATISTICS_update (GST_stats,
+                              "# DV Boxes dropped: next hop unknown",
+                              1,
+                              GNUNET_NO);
+    finish_cmc_handling (cmc);
+    return;
+  }
+  /* We are the target. Unbox and handle message. */
+  GNUNET_STATISTICS_update (GST_stats,
+                            "# DV boxes opened (ultimate target)",
+                            1,
+                            GNUNET_NO);
+  cmc->total_hops = ntohs (dvb->total_hops);
+
+  // DH key derivation with received DV, could be garbage.
+  struct GNUNET_HashCode km;
+
+  if (GNUNET_YES != GNUNET_CRYPTO_eddsa_kem_decaps (GST_my_private_key,
+                                                    &dvb->ephemeral_key,
+                                                    &km))
+  {
+    GNUNET_break_op (0);
+    finish_cmc_handling (cmc);
+    return;
+  }
+  dv_setup_key_state_from_km (&km, &dvb->iv, &key);
+  hdr = (const char *) &dvb[1];
+  hdr_len = ntohs (dvb->orig_size) - sizeof(*dvb) - sizeof(struct
+                                                           GNUNET_PeerIdentity)
+            * ntohs (dvb->total_hops);
+
+  dv_hmac (&key, &hmac, hdr, hdr_len);
+  if (0 != GNUNET_memcmp (&hmac, &dvb->hmac))
+  {
+    /* HMAC mismatch, discard! */
+    GNUNET_break_op (0);
+    finish_cmc_handling (cmc);
+    return;
+  }
+  /* begin actual decryption */
+  {
+    struct Backtalker *b;
+    struct GNUNET_TIME_Absolute monotime;
+    struct TransportDVBoxPayloadP ppay;
+    char body[hdr_len - sizeof(ppay)] GNUNET_ALIGN;
+    const struct GNUNET_MessageHeader *mh;
+
+    GNUNET_assert (hdr_len >=
+                   sizeof(ppay) + sizeof(struct GNUNET_MessageHeader));
+    if (GNUNET_OK != dv_decrypt (&key, &ppay, hdr, sizeof(ppay)))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Error decrypting DV payload header\n");
+      GNUNET_break_op (0);
+      finish_cmc_handling (cmc);
+      return;
+    }
+    if (GNUNET_OK != dv_decrypt (&key, body,
+                                 &hdr[sizeof(ppay)], hdr_len - sizeof(ppay)))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Error decrypting DV payload\n");
+      GNUNET_break_op (0);
+      finish_cmc_handling (cmc);
+      return;
+    }
+    mh = (const struct GNUNET_MessageHeader *) body;
+    dv_key_clean (&key);
+    if (ntohs (mh->size) != sizeof(body))
+    {
+      GNUNET_break_op (0);
+      finish_cmc_handling (cmc);
+      return;
+    }
+    /* need to prevent box-in-a-box (and DV_LEARN) so check inbox type! */
+    switch (ntohs (mh->type))
+    {
+    case GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX:
+      GNUNET_break_op (0);
+      finish_cmc_handling (cmc);
+      return;
+
+    case GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN:
+      GNUNET_break_op (0);
+      finish_cmc_handling (cmc);
+      return;
+
+    default:
+      /* permitted, continue */
+      break;
+    }
+    monotime = GNUNET_TIME_absolute_ntoh (ppay.monotonic_time);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Decrypted backtalk from %s\n",
+                GNUNET_i2s (&ppay.sender));
+    b = GNUNET_CONTAINER_multipeermap_get (backtalkers, &ppay.sender);
+    if ((NULL != b) && (monotime.abs_value_us < b->monotonic_time.abs_value_us))
+    {
+      GNUNET_STATISTICS_update (
+        GST_stats,
+        "# Backchannel messages dropped: monotonic time not increasing",
+        1,
+        GNUNET_NO);
+      finish_cmc_handling (cmc);
+      return;
+    }
+    if ((NULL == b) ||
+        (0 != GNUNET_memcmp (&b->last_ephemeral, &dvb->ephemeral_key)))
+    {
+      /* Check signature */
+      struct EphemeralConfirmationPS ec;
+
+      ec.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL);
+      ec.target = GST_my_identity;
+      ec.ephemeral_key = dvb->ephemeral_key;
+      ec.purpose.size =  htonl (sizeof(ec));
+      ec.sender_monotonic_time = ppay.monotonic_time;
+      if (
+        GNUNET_OK !=
+        GNUNET_CRYPTO_eddsa_verify (
+          GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL,
+          &ec,
+          &ppay.sender_sig,
+          &ppay.sender.public_key))
+      {
+        /* Signature invalid, discard! */
+        GNUNET_break_op (0);
+        finish_cmc_handling (cmc);
+        return;
+      }
+    }
+    /* Update sender, we now know the real origin! */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "DVBox received for me from %s via %s\n",
+                GNUNET_i2s2 (&ppay.sender),
+                GNUNET_i2s (&cmc->im.sender));
+    cmc->im.sender = ppay.sender;
+
+    if (NULL != b)
+    {
+      /* update key cache and mono time */
+      b->last_ephemeral = dvb->ephemeral_key;
+      b->monotonic_time = monotime;
+      update_backtalker_monotime (b);
+      b->timeout =
+        GNUNET_TIME_relative_to_absolute (BACKCHANNEL_INACTIVITY_TIMEOUT);
+      cmc->mh = mh;
+      demultiplex_with_cmc (cmc);
+      return;
+    }
+    /* setup data structure to cache signature AND check
+       monotonic time with PEERSTORE before forwarding backchannel payload */
+    b = GNUNET_malloc (sizeof(struct Backtalker) + sizeof(body));
+    b->pid = ppay.sender;
+    b->body_size = sizeof(body);
+    memcpy (&b[1], body, sizeof(body));
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multipeermap_put (
+                     backtalkers,
+                     &b->pid,
+                     b,
+                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+    b->monotonic_time = monotime; /* NOTE: to be checked still! */
+    b->cmc = cmc;
+    b->timeout =
+      GNUNET_TIME_relative_to_absolute (BACKCHANNEL_INACTIVITY_TIMEOUT);
+    b->task = GNUNET_SCHEDULER_add_at (b->timeout, &backtalker_timeout_cb, b);
+    b->get =
+      GNUNET_PEERSTORE_iteration_start (peerstore,
+                                        "transport",
+                                        &b->pid,
+                                        GNUNET_PEERSTORE_TRANSPORT_BACKCHANNEL_MONOTIME,
+                                        &backtalker_monotime_cb,
+                                        b);
+  } /* end actual decryption */
+}
+
+
+/**
+ * Client notified us about transmission from a peer.  Process the request.
+ *
+ * @param cls a `struct TransportClient` which sent us the message
+ * @param im the send message that was sent
+ * @return #GNUNET_YES if message is well-formed
+ */
+static int
+check_incoming_msg (void *cls,
+                    const struct GNUNET_TRANSPORT_IncomingMessage *im)
+{
+  struct TransportClient *tc = cls;
+
+  if (CT_COMMUNICATOR != tc->type)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_MQ_check_boxed_message (im);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Closure for #check_known_address.
+ */
+struct CheckKnownAddressContext
+{
+  /**
+   * Set to the address we are looking for.
+   */
+  const char *address;
+
+  /**
+   * Set to a matching validation state, if one was found.
+   */
+  struct ValidationState *vs;
+};
+
+
+/**
+ * Test if the validation state in @a value matches the
+ * address from @a cls.
+ *
+ * @param cls a `struct CheckKnownAddressContext`
+ * @param pid unused (must match though)
+ * @param value a `struct ValidationState`
+ * @return #GNUNET_OK if not matching, #GNUNET_NO if match found
+ */
+static int
+check_known_address (void *cls,
+                     const struct GNUNET_PeerIdentity *pid,
+                     void *value)
+{
+  struct CheckKnownAddressContext *ckac = cls;
+  struct ValidationState *vs = value;
+
+  (void) pid;
+  if (0 != strcmp (vs->address, ckac->address))
+    return GNUNET_OK;
+  ckac->vs = vs;
+  return GNUNET_NO;
+}
+
+
+/**
+ * Task run periodically to validate some address based on #validation_heap.
+ *
+ * @param cls NULL
+ */
+static void
+validation_start_cb (void *cls);
+
+
+/**
+ * Set the time for next_challenge of @a vs to @a new_time.
+ * Updates the heap and if necessary reschedules the job.
+ *
+ * @param vs validation state to update
+ * @param new_time new time for revalidation
+ */
+static void
+update_next_challenge_time (struct ValidationState *vs,
+                            struct GNUNET_TIME_Absolute new_time)
+{
+  struct GNUNET_TIME_Relative delta;
+
+  if (new_time.abs_value_us == vs->next_challenge.abs_value_us)
+    return; /* be lazy */
+  vs->next_challenge = new_time;
+  if (NULL == vs->hn)
+    vs->hn =
+      GNUNET_CONTAINER_heap_insert (validation_heap, vs, new_time.abs_value_us);
+  else
+    GNUNET_CONTAINER_heap_update_cost (vs->hn, new_time.abs_value_us);
+  if ((vs != GNUNET_CONTAINER_heap_peek (validation_heap)) &&
+      (NULL != validation_task))
+    return;
+  if (NULL != validation_task)
+    GNUNET_SCHEDULER_cancel (validation_task);
+  /* randomize a bit */
+  delta.rel_value_us =
+    GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+                              MIN_DELAY_ADDRESS_VALIDATION.rel_value_us);
+  new_time = GNUNET_TIME_absolute_add (new_time, delta);
+  validation_task =
+    GNUNET_SCHEDULER_add_at (new_time, &validation_start_cb, NULL);
+}
+
+
+/**
+ * Start address validation.
+ *
+ * @param pid peer the @a address is for
+ * @param address an address to reach @a pid (presumably)
+ */
+static void
+start_address_validation (const struct GNUNET_PeerIdentity *pid,
+                          const char *address)
+{
+  struct GNUNET_TIME_Absolute now;
+  struct ValidationState *vs;
+  struct CheckKnownAddressContext ckac = { .address = address, .vs = NULL };
+
+  (void) GNUNET_CONTAINER_multipeermap_get_multiple (validation_map,
+                                                     pid,
+                                                     &check_known_address,
+                                                     &ckac);
+  if (NULL != (vs = ckac.vs))
+  {
+    /* if 'vs' is not currently valid, we need to speed up retrying the
+     * validation */
+    if (vs->validated_until.abs_value_us < vs->next_challenge.abs_value_us)
+    {
+      /* reduce backoff as we got a fresh advertisement */
+      vs->challenge_backoff =
+        GNUNET_TIME_relative_min (FAST_VALIDATION_CHALLENGE_FREQ,
+                                  GNUNET_TIME_relative_divide (
+                                    vs->challenge_backoff,
+                                    2));
+      update_next_challenge_time (vs,
+                                  GNUNET_TIME_relative_to_absolute (
+                                    vs->challenge_backoff));
+    }
+    return;
+  }
+  now = GNUNET_TIME_absolute_get_monotonic (GST_cfg);
+  vs = GNUNET_new (struct ValidationState);
+  vs->pid = *pid;
+  vs->valid_until =
+    GNUNET_TIME_relative_to_absolute (ADDRESS_VALIDATION_LIFETIME);
+  vs->first_challenge_use = now;
+  vs->validation_rtt = GNUNET_TIME_UNIT_FOREVER_REL;
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE,
+                              &vs->challenge,
+                              sizeof(vs->challenge));
+  vs->address = GNUNET_strdup (address);
+  GNUNET_CRYPTO_hash (vs->address, strlen (vs->address), &vs->hc);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Starting address validation `%s' of peer %s using challenge %s\n",
+              address,
+              GNUNET_i2s (pid),
+              GNUNET_sh2s (&vs->challenge.value));
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multipeermap_put (
+                   validation_map,
+                   &vs->pid,
+                   vs,
+                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  update_next_challenge_time (vs, now);
+}
+
+
+static struct Queue *
+find_queue (const struct GNUNET_PeerIdentity *pid, const char *address);
+
+
+static void
+suggest_to_connect (const struct GNUNET_PeerIdentity *pid, const char *address);
+
+
+static void
+hello_for_incoming_cb (void *cls,
+                       const struct GNUNET_PeerIdentity *pid,
+                       const char *uri)
+{
+  (void) cls;
+  struct Queue *q;
+  int pfx_len;
+  const char *eou;
+  char *address;
+
+  eou = strstr (uri,
+                "://");
+  pfx_len = eou - uri;
+  eou += 3;
+  GNUNET_asprintf (&address,
+                   "%.*s-%s",
+                   pfx_len,
+                   uri,
+                   eou);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "helo for client %s\n",
+              address);
+  q = find_queue (pid, address);
+  if (NULL == q)
+  {
+    suggest_to_connect (pid, address);
+  }
+  else
+    start_address_validation (pid, address);
+  GNUNET_free (address);
+}
+
+
+/**
+ * Function called by PEERSTORE for each matching record.
+ *
+ * @param cls closure, a `struct IncomingRequest`
+ * @param record peerstore record information
+ * @param emsg error message, or NULL if no errors
+ */
+static void
+handle_hello_for_incoming (void *cls,
+                           const struct GNUNET_PEERSTORE_Record *record,
+                           const char *emsg)
+{
+  struct IncomingRequest *ir = cls;
+  struct GNUNET_HELLO_Builder *builder;
+  struct GNUNET_MessageHeader *hello;
+
+  if (NULL != emsg)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Got failure from PEERSTORE: %s\n",
+                emsg);
+    return;
+  }
+  hello = record->value;
+  if (0 == GNUNET_memcmp (&record->peer, &GST_my_identity))
+  {
+    GNUNET_PEERSTORE_monitor_next (ir->nc, 1);
+    return;
+  }
+  builder = GNUNET_HELLO_builder_from_msg (hello);
+  GNUNET_HELLO_builder_iterate (builder,
+                                hello_for_incoming_cb,
+                                NULL);
+  GNUNET_HELLO_builder_free (builder);
+}
+
+
+static void
+hello_for_incoming_error_cb (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Error in PEERSTORE monitoring\n");
+}
+
+
+static void
+hello_for_incoming_sync_cb (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Done with initial PEERSTORE iteration during monitoring\n");
+}
+
+
+/**
+ * Communicator gave us a transport address validation challenge.  Process the
+ * request.
+ *
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
+ * @param tvc the message that was received
+ */
+static void
+handle_validation_challenge (
+  void *cls,
+  const struct TransportValidationChallengeMessage *tvc)
+{
+  struct CommunicatorMessageContext *cmc = cls;
+  struct TransportValidationResponseMessage tvr;
+  struct VirtualLink *vl;
+  struct GNUNET_TIME_RelativeNBO validity_duration;
+  struct IncomingRequest *ir;
+  struct Neighbour *n;
+  struct GNUNET_PeerIdentity sender;
+
+  /* DV-routed messages are not allowed for validation challenges */
+  if (cmc->total_hops > 0)
+  {
+    GNUNET_break_op (0);
+    finish_cmc_handling (cmc);
+    return;
+  }
+  validity_duration = cmc->im.expected_address_validity;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received address validation challenge %s\n",
+              GNUNET_sh2s (&tvc->challenge.value));
+  /* If we have a virtual link, we use this mechanism to signal the
+     size of the flow control window, and to allow the sender
+     to ask for increases. If for us the virtual link is still down,
+     we will always give a window size of zero. */
+  tvr.header.type =
+    htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE);
+  tvr.header.size = htons (sizeof(tvr));
+  tvr.reserved = htonl (0);
+  tvr.challenge = tvc->challenge;
+  tvr.origin_time = tvc->sender_time;
+  tvr.validity_duration = validity_duration;
+  {
+    /* create signature */
+    struct TransportValidationPS tvp = {
+      .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE),
+      .purpose.size = htonl (sizeof(tvp)),
+      .validity_duration = validity_duration,
+      .challenge = tvc->challenge
+    };
+
+    GNUNET_CRYPTO_eddsa_sign (GST_my_private_key,
+                              &tvp,
+                              &tvr.signature);
+  }
+  sender = cmc->im.sender;
+  vl = lookup_virtual_link (&sender);
+  if ((NULL != vl) && (GNUNET_YES == vl->confirmed))
+  {
+    // route_control_message_without_fc (&cmc->im.sender,
+    route_control_message_without_fc (vl,
+                                      &tvr.header,
+                                      RMO_ANYTHING_GOES | RMO_REDUNDANT);
+  }
+  else
+  {
+    /* Use route via neighbour */
+    n = lookup_neighbour (&sender);
+    if (NULL != n)
+      route_via_neighbour (n, &tvr.header,
+                           RMO_ANYTHING_GOES | RMO_REDUNDANT
+                           | RMO_UNCONFIRMED_ALLOWED);
+  }
+
+  finish_cmc_handling (cmc);
+  if (NULL != vl)
+    return;
+
+  /* For us, the link is still down, but we need bi-directional
+     connections (for flow-control and for this to be useful for
+     CORE), so we must try to bring the link up! */
+
+  /* (1) Check existing queues, if any, we may be lucky! */
+  n = lookup_neighbour (&sender);
+  if (NULL != n)
+    for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
+      start_address_validation (&sender, q->address);
+  /* (2) Also try to see if we have addresses in PEERSTORE for this peer
+     we could use */
+  for (ir = ir_head; NULL != ir; ir = ir->next)
+    if (0 == GNUNET_memcmp (&ir->pid, &sender))
+      return;
+  /* we are already trying */
+  ir = GNUNET_new (struct IncomingRequest);
+  ir->pid = sender;
+  GNUNET_CONTAINER_DLL_insert (ir_head, ir_tail, ir);
+
+  ir->nc = GNUNET_PEERSTORE_monitor_start (GST_cfg,
+                                           GNUNET_YES,
+                                           "peerstore",
+                                           NULL,
+                                           GNUNET_PEERSTORE_HELLO_KEY,
+                                           &hello_for_incoming_error_cb,
+                                           NULL,
+                                           &hello_for_incoming_sync_cb,
+                                           NULL,
+                                           &handle_hello_for_incoming,
+                                           ir);
+  ir_total++;
+  /* Bound attempts we do in parallel here, might otherwise get excessive */
+  while (ir_total > MAX_INCOMING_REQUEST)
+    free_incoming_request (ir_head);
+}
+
+
+/**
+ * Closure for #check_known_challenge.
+ */
+struct CheckKnownChallengeContext
+{
+  /**
+   * Set to the challenge we are looking for.
+   */
+  const struct GNUNET_CRYPTO_ChallengeNonceP *challenge;
+
+  /**
+   * Set to a matching validation state, if one was found.
+   */
+  struct ValidationState *vs;
+};
+
+
+/**
+ * Test if the validation state in @a value matches the
+ * challenge from @a cls.
+ *
+ * @param cls a `struct CheckKnownChallengeContext`
+ * @param pid unused (must match though)
+ * @param value a `struct ValidationState`
+ * @return #GNUNET_OK if not matching, #GNUNET_NO if match found
+ */
+static int
+check_known_challenge (void *cls,
+                       const struct GNUNET_PeerIdentity *pid,
+                       void *value)
+{
+  struct CheckKnownChallengeContext *ckac = cls;
+  struct ValidationState *vs = value;
+
+  (void) pid;
+  if (0 != GNUNET_memcmp (&vs->challenge, ckac->challenge))
+    return GNUNET_OK;
+  ckac->vs = vs;
+  return GNUNET_NO;
+}
+
+
+/**
+ * Function called when peerstore is done storing a
+ * validated address.
+ *
+ * @param cls a `struct ValidationState`
+ * @param success #GNUNET_YES on success
+ */
+static void
+peerstore_store_validation_cb (void *cls, int success)
+{
+  struct ValidationState *vs = cls;
+
+  vs->sc = NULL;
+  if (GNUNET_YES == success)
+    return;
+  GNUNET_STATISTICS_update (GST_stats,
+                            "# Peerstore failed to store foreign address",
+                            1,
+                            GNUNET_NO);
+}
+
+
+/**
+ * Find the queue matching @a pid and @a address.
+ *
+ * @param pid peer the queue must go to
+ * @param address address the queue must use
+ * @return NULL if no such queue exists
+ */
+static struct Queue *
+find_queue (const struct GNUNET_PeerIdentity *pid, const char *address)
+{
+  struct Neighbour *n;
+
+  n = lookup_neighbour (pid);
+  if (NULL == n)
+    return NULL;
+  for (struct Queue *pos = n->queue_head; NULL != pos;
+       pos = pos->next_neighbour)
+  {
+    if (0 == strcmp (pos->address, address))
+      return pos;
+  }
+  return NULL;
+}
+
+
+static void
+validation_transmit_on_queue (struct Queue *q, struct ValidationState *vs);
+
+static void
+revalidation_start_cb (void *cls)
+{
+  struct ValidationState *vs = cls;
+  struct Queue *q;
+  struct GNUNET_TIME_Absolute now;
+
+  vs->revalidation_task = NULL;
+  q = find_queue (&vs->pid, vs->address);
+  if (NULL == q)
+  {
+    now = GNUNET_TIME_absolute_get ();
+    vs->awaiting_queue = GNUNET_YES;
+    suggest_to_connect (&vs->pid, vs->address);
+    update_next_challenge_time (vs, now);
+  }
+  else
+    validation_transmit_on_queue (q, vs);
+}
+
+
+static enum GNUNET_GenericReturnValue
+revalidate_map_it (
+  void *cls,
+  const struct GNUNET_HashCode *key,
+  void *value)
+{
+  (void) cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Key in revalidate map  %s \n",
+              GNUNET_h2s (key));
+  return GNUNET_YES;
+}
+
+
+/**
+ * Communicator gave us a transport address validation response.  Process the
+ * request.
+ *
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
+ * @param tvr the message that was received
+ */
+static void
+handle_validation_response (
+  void *cls,
+  const struct TransportValidationResponseMessage *tvr)
+{
+  struct CommunicatorMessageContext *cmc = cls;
+  struct ValidationState *vs;
+  struct CheckKnownChallengeContext ckac = { .challenge = &tvr->challenge,
+                                             .vs = NULL};
+  struct GNUNET_TIME_Absolute origin_time;
+  struct Queue *q;
+  struct Neighbour *n;
+  struct VirtualLink *vl;
+  const struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get_monotonic (
+    GST_cfg);
+
+  /* check this is one of our challenges */
+  (void) GNUNET_CONTAINER_multipeermap_get_multiple (validation_map,
+                                                     &cmc->im.sender,
+                                                     &check_known_challenge,
+                                                     &ckac);
+  if (NULL == (vs = ckac.vs))
+  {
+    /* This can happen simply if we 'forgot' the challenge by now,
+       i.e. because we received the validation response twice */
+    GNUNET_STATISTICS_update (GST_stats,
+                              "# Validations dropped, challenge unknown",
+                              1,
+                              GNUNET_NO);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Validation response %s dropped, challenge unknown\n",
+                GNUNET_sh2s (&tvr->challenge.value));
+    finish_cmc_handling (cmc);
+    return;
+  }
+
+  /* sanity check on origin time */
+  origin_time = GNUNET_TIME_absolute_ntoh (tvr->origin_time);
+  if ((origin_time.abs_value_us < vs->first_challenge_use.abs_value_us) ||
+      (origin_time.abs_value_us > vs->last_challenge_use.abs_value_us))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Diff first use %" PRIu64 " and last use %" PRIu64 "\n",
+                vs->first_challenge_use.abs_value_us - origin_time.abs_value_us,
+                origin_time.abs_value_us - vs->last_challenge_use.abs_value_us);
+    GNUNET_break_op (0);
+    finish_cmc_handling (cmc);
+    return;
+  }
+
+  {
+    /* check signature */
+    struct TransportValidationPS tvp = {
+      .purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE),
+      .purpose.size = htonl (sizeof(tvp)),
+      .validity_duration = tvr->validity_duration,
+      .challenge = tvr->challenge
+    };
+
+    if (
+      GNUNET_OK !=
+      GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_CHALLENGE,
+                                  &tvp,
+                                  &tvr->signature,
+                                  &cmc->im.sender.public_key))
+    {
+      GNUNET_break_op (0);
+      finish_cmc_handling (cmc);
+      return;
+    }
+  }
+
+  /* validity is capped by our willingness to keep track of the
+     validation entry and the maximum the other peer allows */
+  vs->valid_until = GNUNET_TIME_relative_to_absolute (
+    GNUNET_TIME_relative_min (GNUNET_TIME_relative_ntoh (
+                                tvr->validity_duration),
+                              MAX_ADDRESS_VALID_UNTIL));
+  vs->validated_until =
+    GNUNET_TIME_absolute_min (vs->valid_until,
+                              GNUNET_TIME_relative_to_absolute (
+                                ADDRESS_VALIDATION_LIFETIME));
+  vs->validation_rtt = GNUNET_TIME_absolute_get_duration (origin_time);
+  vs->challenge_backoff = GNUNET_TIME_UNIT_ZERO;
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE,
+                              &vs->challenge,
+                              sizeof(vs->challenge));
+  vs->first_challenge_use = GNUNET_TIME_absolute_subtract (
+    vs->validated_until,
+    GNUNET_TIME_relative_multiply (vs->validation_rtt,
+                                   VALIDATION_RTT_BUFFER_FACTOR));
+  if (GNUNET_TIME_absolute_cmp (vs->first_challenge_use, <, now))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "First challenge use is now %" PRIu64 " %s \n",
+                vs->first_challenge_use.abs_value_us,
+                GNUNET_sh2s (&vs->challenge.value));
+    vs->first_challenge_use = now;
+  }
+  else
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "First challenge use is later %" PRIu64 " %s \n",
+                vs->first_challenge_use.abs_value_us,
+                GNUNET_sh2s (&vs->challenge.value));
+  vs->last_challenge_use =
+    GNUNET_TIME_UNIT_ZERO_ABS; /* challenge was not yet used */
+  update_next_challenge_time (vs, vs->first_challenge_use);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Validation response %s from %s accepted, address valid until %s\n",
+              GNUNET_sh2s (&tvr->challenge.value),
+              GNUNET_i2s (&cmc->im.sender),
+              GNUNET_STRINGS_absolute_time_to_string (vs->valid_until));
+  /*memcpy (&hkey,
+          &hc,
+          sizeof (hkey));*/
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Key %s for address %s map size %u contains %u\n",
+              GNUNET_h2s (&vs->hc),
+              vs->address,
+              GNUNET_CONTAINER_multihashmap_size (revalidation_map),
+              GNUNET_CONTAINER_multihashmap_contains (revalidation_map,
+                                                      &vs->hc));
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_put (
+                   revalidation_map,
+                   &vs->hc,
+                   vs,
+                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  GNUNET_CONTAINER_multihashmap_iterate (revalidation_map,
+                                         revalidate_map_it,
+                                         NULL);
+  vs->revalidation_task =
+    GNUNET_SCHEDULER_add_at (GNUNET_TIME_absolute_subtract (vs->next_challenge,
+                                                            GNUNET_TIME_UNIT_MINUTES),
+                             &revalidation_start_cb, vs);
+  vs->sc = GNUNET_PEERSTORE_store (peerstore,
+                                   "transport",
+                                   &cmc->im.sender,
+                                   GNUNET_PEERSTORE_TRANSPORT_URLADDRESS_KEY,
+                                   vs->address,
+                                   strlen (vs->address) + 1,
+                                   vs->valid_until,
+                                   GNUNET_PEERSTORE_STOREOPTION_MULTIPLE,
+                                   &peerstore_store_validation_cb,
+                                   vs);
+  finish_cmc_handling (cmc);
+
+  /* Finally, we now possibly have a confirmed (!) working queue,
+     update queue status (if queue still is around) */
+  q = find_queue (&vs->pid, vs->address);
+  if (NULL == q)
+  {
+    GNUNET_STATISTICS_update (GST_stats,
+                              "# Queues lost at time of successful validation",
+                              1,
+                              GNUNET_NO);
+    return;
+  }
+  q->validated_until = vs->validated_until;
+  q->pd.aged_rtt = vs->validation_rtt;
+  n = q->neighbour;
+  vl = lookup_virtual_link (&vs->pid);
+  if (NULL == vl)
+  {
+    vl = GNUNET_new (struct VirtualLink);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Creating new virtual link %p to %s using direct neighbour!\n",
+                vl,
+                GNUNET_i2s (&vs->pid));
+    vl->confirmed = GNUNET_YES;
+    vl->message_uuid_ctr =
+      GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
+    vl->target = n->pid;
+    vl->core_recv_window = RECV_WINDOW_SIZE;
+    vl->available_fc_window_size = DEFAULT_WINDOW_SIZE;
+    vl->incoming_fc_window_size = DEFAULT_WINDOW_SIZE;
+    GNUNET_break (GNUNET_YES ==
+                  GNUNET_CONTAINER_multipeermap_put (
+                    links,
+                    &vl->target,
+                    vl,
+                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+    vl->n = n;
+    n->vl = vl;
+    q->idle = GNUNET_YES;
+    vl->visibility_task =
+      GNUNET_SCHEDULER_add_at (q->validated_until, &check_link_down, vl);
+    consider_sending_fc (vl);
+    /* We lacked a confirmed connection to the target
+       before, so tell CORE about it (finally!) */
+    cores_send_connect_info (&n->pid);
+    send_msg_from_cache (vl);
+  }
+  else
+  {
+    /* Link was already up, remember n is also now available and we are done */
+    if (NULL == vl->n)
+    {
+      vl->n = n;
+      n->vl = vl;
+      if (GNUNET_YES == vl->confirmed)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Virtual link to %s could now also use direct neighbour!\n",
+                    GNUNET_i2s (&vs->pid));
+    }
+    else
+    {
+      GNUNET_assert (n == vl->n);
+    }
+    if (GNUNET_NO == vl->confirmed)
+    {
+      vl->confirmed = GNUNET_YES;
+      q->idle = GNUNET_YES;
+      vl->visibility_task =
+        GNUNET_SCHEDULER_add_at (q->validated_until, &check_link_down, vl);
+      consider_sending_fc (vl);
+      /* We lacked a confirmed connection to the target
+         before, so tell CORE about it (finally!) */
+      cores_send_connect_info (&n->pid);
+      send_msg_from_cache (vl);
+    }
+  }
+}
+
+
+/**
+ * Incoming meessage.  Process the request.
+ *
+ * @param im the send message that was received
+ */
+static void
+handle_incoming_msg (void *cls,
+                     const struct GNUNET_TRANSPORT_IncomingMessage *im)
+{
+  struct TransportClient *tc = cls;
+  struct CommunicatorMessageContext *cmc =
+    GNUNET_new (struct CommunicatorMessageContext);
+
+  cmc->tc = tc;
+  cmc->im = *im;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received message with size %u and flow control id %" PRIu64
+              " via communicator from peer %s\n",
+              ntohs (im->header.size),
+              im->fc_id,
+              GNUNET_i2s (&im->sender));
+  cmc->im.neighbour_sender = cmc->im.sender;
+  cmc->mh = (const struct GNUNET_MessageHeader *) &im[1];
+  demultiplex_with_cmc (cmc);
+}
+
+/**
+ * Communicator gave us a transport address validation response.  Check the
+ * request.
+ *
+ * @param cls a `struct CommunicatorMessageContext`
+ * @param fc the message that was received
+ * @return #GNUNET_YES if message is well-formed
+ */
+static int
+check_flow_control (void *cls, const struct TransportFlowControlMessage *fc)
+{
+  (void) cls;
+  unsigned int number_of_addresses = ntohl (fc->number_of_addresses);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Flow control header size %u size of addresses %u number of addresses %u size of message struct %lu second struct %lu\n",
+              ntohs (fc->header.size),
+              ntohl (fc->size_of_addresses),
+              ntohl (fc->number_of_addresses),
+              sizeof(struct TransportFlowControlMessage),
+              sizeof (struct TransportGlobalNattedAddress));
+
+  if (0 == number_of_addresses || ntohs (fc->header.size) == sizeof(struct TransportFlowControlMessage) + ntohl (fc->number_of_addresses) * sizeof (struct TransportGlobalNattedAddress) + ntohl (fc->size_of_addresses))
+    return GNUNET_OK;
+  else
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+}
+
+/**
+ * Communicator gave us a transport address validation response.  Process the
+ * request.
+ *
+ * @param cls a `struct CommunicatorMessageContext` (must call
+ * #finish_cmc_handling() when done)
+ * @param fc the message that was received
+ */
+static void
+handle_flow_control (void *cls, const struct TransportFlowControlMessage *fc)
+{
+  struct CommunicatorMessageContext *cmc = cls;
+  struct VirtualLink *vl;
+  uint32_t seq;
+  struct GNUNET_TIME_Absolute st;
+  uint64_t os;
+  uint64_t wnd;
+  uint32_t random;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received FC from %s\n", GNUNET_i2s (&cmc->im.sender));
+  vl = lookup_virtual_link (&cmc->im.sender);
+  if (NULL == vl)
+  {
+    vl = GNUNET_new (struct VirtualLink);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No virtual link for %p FC creating new unconfirmed virtual link to %s!\n",
+                vl,
+                GNUNET_i2s (&cmc->im.sender));
+    vl->confirmed = GNUNET_NO;
+    vl->message_uuid_ctr =
+      GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
+    vl->target = cmc->im.sender;
+    vl->core_recv_window = RECV_WINDOW_SIZE;
+    vl->available_fc_window_size = DEFAULT_WINDOW_SIZE;
+    vl->incoming_fc_window_size = DEFAULT_WINDOW_SIZE;
+    GNUNET_break (GNUNET_YES ==
+                  GNUNET_CONTAINER_multipeermap_put (
+                    links,
+                    &vl->target,
+                    vl,
+                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  }
+  if (0 != ntohl (fc->number_of_addresses))
+  {
+    unsigned int number_of_addresses = ntohl (fc->number_of_addresses);
+    const char *tgnas;
+    unsigned int off = 0;
+
+    tgnas = (const char *) &fc[1];
+
+    for (int i = 1; i <= number_of_addresses; i++)
+    {
+      struct TransportGlobalNattedAddress *tgna = (struct TransportGlobalNattedAddress *) &tgnas[off];
+      char *addr = (char *) &tgna[1];
+      unsigned int address_length;
+
+      address_length = ntohl (tgna->address_length);
+      off += sizeof(struct TransportGlobalNattedAddress) + address_length;
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "received address %s length %u\n",
+              addr,
+              ntohl (tgna->address_length));
+
+      GNUNET_NAT_add_global_address (nh, addr, ntohl (tgna->address_length));
+    }
+  }
+  st = GNUNET_TIME_absolute_ntoh (fc->sender_time);
+  if (st.abs_value_us < vl->last_fc_timestamp.abs_value_us)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "FC dropped: Message out of order\n");
+    /* out of order, drop */
+    GNUNET_STATISTICS_update (GST_stats,
+                              "# FC dropped: message out of order",
+                              1,
+                              GNUNET_NO);
+    finish_cmc_handling (cmc);
+    return;
+  }
+  seq = ntohl (fc->seq);
+  if (seq < vl->last_fc_seq)
+  {
+    /* Wrap-around/reset of other peer; start all counters from zero */
+    vl->outbound_fc_window_size_used = 0;
+  }
+  vl->last_fc_seq = seq;
+  vl->last_fc_timestamp = st;
+  vl->outbound_fc_window_size = GNUNET_ntohll (fc->inbound_window_size);
+  os = GNUNET_ntohll (fc->outbound_sent);
+  vl->incoming_fc_window_size_loss =
+    (int64_t) (os - vl->incoming_fc_window_size_used);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received FC from %s, seq %u, new window %llu (loss at %lld)\n",
+              GNUNET_i2s (&vl->target),
+              (unsigned int) seq,
+              (unsigned long long) vl->outbound_fc_window_size,
+              (long long) vl->incoming_fc_window_size_loss);
+  wnd = GNUNET_ntohll (fc->outbound_window_size);
+  random = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                     UINT32_MAX);
+  if ((GNUNET_YES == vl->confirmed) && ((wnd < vl->incoming_fc_window_size
+                                         + vl->incoming_fc_window_size_used
+                                         + vl->incoming_fc_window_size_loss) ||
+                                        (vl->last_outbound_window_size_received
+                                         != wnd) ||
+                                        (0 == random
+                                         % FC_NO_CHANGE_REPLY_PROBABILITY)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Consider re-sending our FC message, as clearly the other peer's idea of the window is not up-to-date (%llu vs %llu) or %llu last received differs, or random reply %u\n",
+                (unsigned long long) wnd,
+                (unsigned long long) vl->incoming_fc_window_size,
+                (unsigned long long) vl->last_outbound_window_size_received,
+                random % FC_NO_CHANGE_REPLY_PROBABILITY);
+    consider_sending_fc (vl);
+  }
+  if ((wnd == vl->incoming_fc_window_size
+       + vl->incoming_fc_window_size_used
+       + vl->incoming_fc_window_size_loss) &&
+      (vl->last_outbound_window_size_received == wnd) &&
+      (NULL != vl->fc_retransmit_task))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Stopping FC retransmission to %s: peer is current at window %llu\n",
+                GNUNET_i2s (&vl->target),
+                (unsigned long long) wnd);
+    GNUNET_SCHEDULER_cancel (vl->fc_retransmit_task);
+    vl->fc_retransmit_task = NULL;
+    vl->fc_retransmit_count = 0;
+  }
+  vl->last_outbound_window_size_received = wnd;
+  /* FC window likely increased, check transmission possibilities! */
+  check_vl_transmission (vl);
+  finish_cmc_handling (cmc);
+}
+
+
+/**
+ * Given an inbound message @a msg from a communicator @a cmc,
+ * demultiplex it based on the type calling the right handler.
+ *
+ * @param cmc context for demultiplexing
+ * @param msg message to demultiplex
+ */
+static void
+demultiplex_with_cmc (struct CommunicatorMessageContext *cmc)
+{
+  struct GNUNET_MQ_MessageHandler handlers[] =
+  { GNUNET_MQ_hd_var_size (fragment_box,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT,
+                           struct TransportFragmentBoxMessage,
+                           cmc),
+    GNUNET_MQ_hd_var_size (reliability_box,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX,
+                           struct TransportReliabilityBoxMessage,
+                           cmc),
+    GNUNET_MQ_hd_var_size (reliability_ack,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_ACK,
+                           struct TransportReliabilityAckMessage,
+                           cmc),
+    GNUNET_MQ_hd_var_size (backchannel_encapsulation,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_BACKCHANNEL_ENCAPSULATION,
+                           struct TransportBackchannelEncapsulationMessage,
+                           cmc),
+    GNUNET_MQ_hd_var_size (dv_learn,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN,
+                           struct TransportDVLearnMessage,
+                           cmc),
+    GNUNET_MQ_hd_var_size (dv_box,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX,
+                           struct TransportDVBoxMessage,
+                           cmc),
+    GNUNET_MQ_hd_var_size (flow_control,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL,
+                           struct TransportFlowControlMessage,
+                           cmc),
+    GNUNET_MQ_hd_fixed_size (
+      validation_challenge,
+      GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE,
+      struct TransportValidationChallengeMessage,
+      cmc),
+    GNUNET_MQ_hd_fixed_size (
+      validation_response,
+      GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE,
+      struct TransportValidationResponseMessage,
+      cmc),
+    GNUNET_MQ_handler_end () };
+  int ret;
+  const struct GNUNET_MessageHeader *msg = cmc->mh;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Handling message of type %u with %u bytes\n",
+              (unsigned int) ntohs (msg->type),
+              (unsigned int) ntohs (msg->size));
+  ret = GNUNET_MQ_handle_message (handlers, msg);
+  if (GNUNET_SYSERR == ret)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (cmc->tc->client);
+    GNUNET_free (cmc);
+    return;
+  }
+  if (GNUNET_NO == ret)
+  {
+    /* unencapsulated 'raw' message */
+    handle_raw_message (cmc, msg);
+  }
+}
+
+
+/**
+ * New queue became available.  Check message.
+ *
+ * @param cls the client
+ * @param aqm the send message that was sent
+ */
+static int
+check_add_queue_message (void *cls,
+                         const struct GNUNET_TRANSPORT_AddQueueMessage *aqm)
+{
+  struct TransportClient *tc = cls;
+
+  if (CT_COMMUNICATOR != tc->type)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_MQ_check_zero_termination (aqm);
+  return GNUNET_OK;
+}
+
+
+/**
+ * If necessary, generates the UUID for a @a pm
+ *
+ * @param pm pending message to generate UUID for.
+ */
+static void
+set_pending_message_uuid (struct PendingMessage *pm)
+{
+  if (pm->msg_uuid_set)
+    return;
+  pm->msg_uuid.uuid = pm->vl->message_uuid_ctr++;
+  pm->msg_uuid_set = GNUNET_YES;
+}
+
+
+/**
+ * Setup data structure waiting for acknowledgements.
+ *
+ * @param queue queue the @a pm will be sent over
+ * @param dvh path the message will take, may be NULL
+ * @param pm the pending message for transmission
+ * @return corresponding fresh pending acknowledgement
+ */
+static struct PendingAcknowledgement *
+prepare_pending_acknowledgement (struct Queue *queue,
+                                 struct DistanceVectorHop *dvh,
+                                 struct PendingMessage *pm)
+{
+  struct PendingAcknowledgement *pa;
+
+  pa = GNUNET_new (struct PendingAcknowledgement);
+  pa->queue = queue;
+  pa->dvh = dvh;
+  pa->pm = pm;
+  do
+  {
+    GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE,
+                                &pa->ack_uuid,
+                                sizeof(pa->ack_uuid));
+  }
+  while (GNUNET_YES != GNUNET_CONTAINER_multiuuidmap_put (
+           pending_acks,
+           &pa->ack_uuid.value,
+           pa,
+           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  GNUNET_CONTAINER_MDLL_insert (queue, queue->pa_head, queue->pa_tail, pa);
+  GNUNET_CONTAINER_MDLL_insert (pm, pm->pa_head, pm->pa_tail, pa);
+  if (NULL != dvh)
+    GNUNET_CONTAINER_MDLL_insert (dvh, dvh->pa_head, dvh->pa_tail, pa);
+  pa->transmission_time = GNUNET_TIME_absolute_get ();
+  pa->message_size = pm->bytes_msg;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Waiting for ACKnowledgment `%s' for <%" PRIu64 ">\n",
+              GNUNET_uuid2s (&pa->ack_uuid.value),
+              pm->logging_uuid);
+  return pa;
+}
+
+
+/**
+ * Fragment the given @a pm to the given @a mtu.  Adds
+ * additional fragments to the neighbour as well. If the
+ * @a mtu is too small, generates and error for the @a pm
+ * and returns NULL.
+ *
+ * @param queue which queue to fragment for
+ * @param dvh path the message will take, or NULL
+ * @param pm pending message to fragment for transmission
+ * @return new message to transmit
+ */
+static struct PendingMessage *
+fragment_message (struct Queue *queue,
+                  struct DistanceVectorHop *dvh,
+                  struct PendingMessage *pm)
+{
+  struct PendingAcknowledgement *pa;
+  struct PendingMessage *ff;
+  uint16_t mtu;
+  uint16_t msize;
+
+  mtu = (UINT16_MAX == queue->mtu)
+        ? UINT16_MAX - sizeof(struct GNUNET_TRANSPORT_SendMessageTo)
+        : queue->mtu;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Fragmenting message <%" PRIu64
+              "> with size %u to %s for MTU %u\n",
+              pm->logging_uuid,
+              pm->bytes_msg,
+              GNUNET_i2s (&pm->vl->target),
+              (unsigned int) mtu);
+  set_pending_message_uuid (pm);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Fragmenting message %" PRIu64 " <%" PRIu64
+              "> with size %u to %s for MTU %u\n",
+              pm->msg_uuid.uuid,
+              pm->logging_uuid,
+              pm->bytes_msg,
+              GNUNET_i2s (&pm->vl->target),
+              (unsigned int) mtu);
+
+  /* This invariant is established in #handle_add_queue_message() */
+  GNUNET_assert (mtu > sizeof(struct TransportFragmentBoxMessage));
+
+  /* select fragment for transmission, descending the tree if it has
+     been expanded until we are at a leaf or at a fragment that is small
+     enough
+   */
+  ff = pm;
+  msize = ff->bytes_msg;
+
+  while (((ff->bytes_msg > mtu) || (pm == ff)) &&
+         (ff->frag_off == msize) && (NULL != ff->head_frag))
+  {
+    ff = ff->head_frag;   /* descent into fragmented fragments */
+    msize = ff->bytes_msg - sizeof(struct TransportFragmentBoxMessage);
+  }
+
+  if (((ff->bytes_msg > mtu) || (pm == ff)) && (ff->frag_off < msize))
+  {
+    /* Did not yet calculate all fragments, calculate next fragment */
+    struct PendingMessage *frag;
+    struct TransportFragmentBoxMessage tfb;
+    const char *orig;
+    char *msg;
+    uint16_t fragmax;
+    uint16_t fragsize;
+    uint16_t msize;
+    uint16_t xoff = 0;
+    pm->frag_count++;
+
+    orig = (const char *) &ff[1];
+    msize = ff->bytes_msg;
+    if (pm != ff)
+    {
+      const struct TransportFragmentBoxMessage *tfbo;
+
+      tfbo = (const struct TransportFragmentBoxMessage *) orig;
+      orig += sizeof(struct TransportFragmentBoxMessage);
+      msize -= sizeof(struct TransportFragmentBoxMessage);
+      xoff = ntohs (tfbo->frag_off);
+    }
+    fragmax = mtu - sizeof(struct TransportFragmentBoxMessage);
+    fragsize = GNUNET_MIN (msize - ff->frag_off, fragmax);
+    frag =
+      GNUNET_malloc (sizeof(struct PendingMessage)
+                     + sizeof(struct TransportFragmentBoxMessage) + fragsize);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "3 created pm %p from pm %p storing vl %p from pm %p\n",
+                frag,
+                ff,
+                pm->vl,
+                pm);
+    frag->logging_uuid = logging_uuid_gen++;
+    frag->vl = pm->vl;
+    frag->frag_parent = ff;
+    frag->timeout = pm->timeout;
+    frag->bytes_msg = sizeof(struct TransportFragmentBoxMessage) + fragsize;
+    frag->pmt = PMT_FRAGMENT_BOX;
+    msg = (char *) &frag[1];
+    tfb.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_FRAGMENT);
+    tfb.header.size =
+      htons (sizeof(struct TransportFragmentBoxMessage) + fragsize);
+    pa = prepare_pending_acknowledgement (queue, dvh, frag);
+    tfb.ack_uuid = pa->ack_uuid;
+    tfb.msg_uuid = pm->msg_uuid;
+    tfb.frag_off = htons (ff->frag_off + xoff);
+    tfb.msg_size = htons (pm->bytes_msg);
+    memcpy (msg, &tfb, sizeof(tfb));
+    memcpy (&msg[sizeof(tfb)], &orig[ff->frag_off], fragsize);
+    GNUNET_CONTAINER_MDLL_insert (frag, ff->head_frag,
+                                  ff->tail_frag, frag);
+    ff->frag_off += fragsize;
+    ff = frag;
+  }
+
+  /* Move head to the tail and return it */
+  GNUNET_CONTAINER_MDLL_remove (frag,
+                                ff->frag_parent->head_frag,
+                                ff->frag_parent->tail_frag,
+                                ff);
+  GNUNET_CONTAINER_MDLL_insert_tail (frag,
+                                     ff->frag_parent->head_frag,
+                                     ff->frag_parent->tail_frag,
+                                     ff);
+
+  return ff;
+}
+
+
+/**
+ * Reliability-box the given @a pm. On error (can there be any), NULL
+ * may be returned, otherwise the "replacement" for @a pm (which
+ * should then be added to the respective neighbour's queue instead of
+ * @a pm).  If the @a pm is already fragmented or reliability boxed,
+ * or itself an ACK, this function simply returns @a pm.
+ *
+ * @param queue which queue to prepare transmission for
+ * @param dvh path the message will take, or NULL
+ * @param pm pending message to box for transmission over unreliabile queue
+ * @return new message to transmit
+ */
+static struct PendingMessage *
+reliability_box_message (struct Queue *queue,
+                         struct DistanceVectorHop *dvh,
+                         struct PendingMessage *pm)
+{
+  struct TransportReliabilityBoxMessage rbox;
+  struct PendingAcknowledgement *pa;
+  struct PendingMessage *bpm;
+  char *msg;
+
+  if ((PMT_CORE != pm->pmt) && (PMT_DV_BOX != pm->pmt))
+    return pm; /* already fragmented or reliability boxed, or control message:
+                  do nothing */
+  if (NULL != pm->bpm)
+    return pm->bpm; /* already computed earlier: do nothing */
+  // TODO I guess we do not need this assertion. We might have a DLL with
+  // fragments, because the MTU changed, and we do not need to fragment anymore.
+  // But we should keep the fragments until message was completed, because
+  // the MTU might change again.
+  // GNUNET_assert (NULL == pm->head_frag);
+  if (pm->bytes_msg + sizeof(rbox) > UINT16_MAX)
+  {
+    /* failed hard */
+    GNUNET_break (0);
+    client_send_response (pm);
+    return NULL;
+  }
+
+  pa = prepare_pending_acknowledgement (queue, dvh, pm);
+
+  bpm = GNUNET_malloc (sizeof(struct PendingMessage) + sizeof(rbox)
+                       + pm->bytes_msg);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "4 created pm %p storing vl %p from pm %p\n",
+              bpm,
+              pm->vl,
+              pm);
+  bpm->logging_uuid = logging_uuid_gen++;
+  bpm->vl = pm->vl;
+  bpm->frag_parent = pm;
+  // Why was this needed?
+  // GNUNET_CONTAINER_MDLL_insert (frag, pm->head_frag, pm->tail_frag, bpm);
+  bpm->timeout = pm->timeout;
+  bpm->pmt = PMT_RELIABILITY_BOX;
+  bpm->bytes_msg = pm->bytes_msg + sizeof(rbox);
+  set_pending_message_uuid (bpm);
+  rbox.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_RELIABILITY_BOX);
+  rbox.header.size = htons (sizeof(rbox) + pm->bytes_msg);
+  rbox.ack_countdown = htonl (0);  // FIXME: implement ACK countdown support
+
+  rbox.ack_uuid = pa->ack_uuid;
+  msg = (char *) &bpm[1];
+  memcpy (msg, &rbox, sizeof(rbox));
+  memcpy (&msg[sizeof(rbox)], &pm[1], pm->bytes_msg);
+  pm->bpm = bpm;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Preparing reliability box for message <%" PRIu64
+              "> of size %d (%d) to %s on queue %s\n",
+              pm->logging_uuid,
+              pm->bytes_msg,
+              ntohs (((const struct GNUNET_MessageHeader *) &pm[1])->size),
+              GNUNET_i2s (&pm->vl->target),
+              queue->address);
+  return bpm;
+}
+
+
+static void
+reorder_root_pm (struct PendingMessage *pm,
+                 struct GNUNET_TIME_Absolute next_attempt)
+{
+  struct VirtualLink *vl = pm->vl;
+  struct PendingMessage *pos;
+
+  /* re-insert sort in neighbour list */
+  GNUNET_CONTAINER_MDLL_remove (vl,
+                                vl->pending_msg_head,
+                                vl->pending_msg_tail,
+                                pm);
+  pos = vl->pending_msg_tail;
+  while ((NULL != pos) &&
+         (next_attempt.abs_value_us > pos->next_attempt.abs_value_us))
+    pos = pos->prev_vl;
+  GNUNET_CONTAINER_MDLL_insert_after (vl,
+                                      vl->pending_msg_head,
+                                      vl->pending_msg_tail,
+                                      pos,
+                                      pm);
+}
+
+
+static unsigned int
+check_next_attempt_tree (struct PendingMessage *pm, struct PendingMessage *root)
+{
+  struct PendingMessage *pos;
+  enum GNUNET_GenericReturnValue frags_in_flight;
+
+  pos = pm->head_frag;
+  while (NULL != pos)
+  {
+    if (pos->frags_in_flight_round == pm->frags_in_flight_round ||
+        GNUNET_NO == check_next_attempt_tree (pos, root))
+      frags_in_flight = GNUNET_NO;
+    else
+    {
+      frags_in_flight = GNUNET_YES;
+      break;
+    }
+    pos = pos->next_frag;
+  }
+
+  return frags_in_flight;
+}
+
+
+static void
+harmonize_flight_round (struct PendingMessage *pm)
+{
+  struct PendingMessage *pos;
+
+  pos = pm->head_frag;
+  while (NULL != pos)
+  {
+    pos->frags_in_flight_round = pm->frags_in_flight_round;
+    harmonize_flight_round (pos);
+    pos = pos->next_frag;
+  }
+}
+
+
+/**
+ * Change the value of the `next_attempt` field of @a pm
+ * to @a next_attempt and re-order @a pm in the transmission
+ * list as required by the new timestamp.
+ *
+ * @param pm a pending message to update
+ * @param next_attempt timestamp to use
+ */
+static void
+update_pm_next_attempt (struct PendingMessage *pm,
+                        struct GNUNET_TIME_Absolute next_attempt)
+{
+  if (NULL == pm->frag_parent)
+  {
+    pm->next_attempt = next_attempt;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Next attempt for message <%" PRIu64 "> set to %" PRIu64 "\n",
+                pm->logging_uuid,
+                next_attempt.abs_value_us);
+    reorder_root_pm (pm, next_attempt);
+  }
+  else if ((PMT_RELIABILITY_BOX == pm->pmt) || (PMT_DV_BOX == pm->pmt))// || (PMT_FRAGMENT_BOX == pm->pmt))
+  {
+    struct PendingMessage *root = pm->frag_parent;
+
+    while (NULL != root->frag_parent)
+      root = root->frag_parent;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Next attempt for root message <%" PRIu64 "> set to %s\n",
+                root->logging_uuid,
+                GNUNET_STRINGS_absolute_time_to_string (next_attempt));
+    root->next_attempt = next_attempt;
+    reorder_root_pm (root, next_attempt);
+  }
+  else
+  {
+    struct PendingMessage *root = pm->frag_parent;
+
+    while (NULL != root->frag_parent && PMT_DV_BOX != root->pmt)
+      root = root->frag_parent;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "frag_count next atempt %u\n",
+                root->frag_count);
+
+    if (GNUNET_NO == root->frags_in_flight)
+    {
+      root->next_attempt = next_attempt;
+      harmonize_flight_round (root);
+      root->frags_in_flight_round++;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Next attempt for fragmented message <%" PRIu64 "> (<%" PRIu64
+                  ">)set to %" PRIu64 "\n",
+                  pm->logging_uuid,
+                  root->logging_uuid,
+                  next_attempt.abs_value_us);
+    }
+
+    pm->next_attempt = root->next_attempt;
+    pm->frags_in_flight_round = root->frags_in_flight_round;
+    harmonize_flight_round (pm);
+
+    if (root->bytes_msg == root->frag_off)
+      root->frags_in_flight = check_next_attempt_tree (root, root);
+    else
+      root->frags_in_flight = GNUNET_YES;
+
+    if (GNUNET_NO == root->frags_in_flight)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "We have no fragments in flight for message %" PRIu64
+                  ", reorder root! Next attempt is %" PRIu64 "\n",
+                  root->logging_uuid,
+                  root->next_attempt.abs_value_us);
+      if (PMT_DV_BOX == root->pmt)
+        root = root->frag_parent;
+      reorder_root_pm (root, root->next_attempt);
+      // root->next_attempt = GNUNET_TIME_UNIT_ZERO_ABS;
+    }
+    else
+    {
+      double factor = ((double) root->frag_count - 1)
+                      / (double) root->frag_count;
+      struct GNUNET_TIME_Relative s1;
+      struct GNUNET_TIME_Relative s2;
+      struct GNUNET_TIME_Relative plus_mean =
+        GNUNET_TIME_absolute_get_remaining (root->next_attempt);
+      struct GNUNET_TIME_Relative plus = GNUNET_TIME_absolute_get_remaining (
+        next_attempt);
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "frag_count %u after factor\n",
+                  root->frag_count);
+      s1 = GNUNET_TIME_relative_multiply_double (plus_mean,
+                                                 factor);
+      s2 = GNUNET_TIME_relative_divide (plus,
+                                        root->frag_count);
+      plus_mean = GNUNET_TIME_relative_add (s1, s2);
+      root->next_attempt = GNUNET_TIME_relative_to_absolute (plus_mean);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "We have fragments in flight for message %" PRIu64
+                  ", do not reorder root! Actual next attempt %" PRIu64 "\n",
+                  root->logging_uuid,
+                  root->next_attempt.abs_value_us);
+    }
+  }
+}
+
+
+/**
+ * Context for #select_best_pending_from_link().
+ */
+struct PendingMessageScoreContext
+{
+  /**
+   * Set to the best message that was found, NULL for none.
+   */
+  struct PendingMessage *best;
+
+  /**
+   * DVH that @e best should take, or NULL for direct transmission.
+   */
+  struct DistanceVectorHop *dvh;
+
+  /**
+   * What is the estimated total overhead for this message?
+   */
+  size_t real_overhead;
+
+  /**
+   * Number of pending messages we seriously considered this time.
+   */
+  unsigned int consideration_counter;
+
+  /**
+   * Did we have to fragment?
+   */
+  int frag;
+
+  /**
+   * Did we have to reliability box?
+   */
+  int relb;
+
+  /**
+   * There are pending messages, but it was to early to send one of them.
+   */
+  int to_early;
+
+  /**
+   * There is a pending messages we are sending fragments at the moment.
+   */
+  unsigned int frags_in_flight;
+
+  /**
+   * When will we try to transmit the message again for which it was to early to retry.
+   */
+  struct GNUNET_TIME_Relative to_early_retry_delay;
+};
+
+
+/**
+ * Select the best pending message from @a vl for transmission
+ * via @a queue.
+ *
+ * @param[in,out] sc best message so far (NULL for none), plus scoring data
+ * @param queue the queue that will be used for transmission
+ * @param vl the virtual link providing the messages
+ * @param dvh path we are currently considering, or NULL for none
+ * @param overhead number of bytes of overhead to be expected
+ *        from DV encapsulation (0 for without DV)
+ */
+static void
+select_best_pending_from_link (struct PendingMessageScoreContext *sc,
+                               struct Queue *queue,
+                               struct VirtualLink *vl,
+                               struct DistanceVectorHop *dvh,
+                               size_t overhead)
+{
+  struct GNUNET_TIME_Absolute now;
+
+  now = GNUNET_TIME_absolute_get ();
+  sc->to_early = GNUNET_NO;
+  sc->frags_in_flight = GNUNET_NO;
+  for (struct PendingMessage *pos = vl->pending_msg_head; NULL != pos;
+       pos = pos->next_vl)
+  {
+    size_t real_overhead = overhead;
+    int frag;
+    int relb;
+
+    if ((NULL != dvh) && (PMT_DV_BOX == pos->pmt))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "DV messages must not be DV-routed to next hop!\n");
+      continue;   /* DV messages must not be DV-routed to next hop! */
+    }
+    if (pos->next_attempt.abs_value_us > now.abs_value_us)
+    {
+      if (GNUNET_YES == pos->frags_in_flight)
+      {
+        sc->frags_in_flight = GNUNET_YES;
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Fragments in flight for message %" PRIu64 "\n",
+                    pos->logging_uuid);
+      }
+      else
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Maybe too early, because message are sorted by next_attempt, if there are no fragments in flight.Checked message %"
+                    PRIu64 "\n",
+                    pos->logging_uuid);
+        sc->to_early = GNUNET_YES;
+        sc->to_early_retry_delay = GNUNET_TIME_absolute_get_remaining (
+          pos->next_attempt);
+        continue;
+      }
+      // break;   /* too early for all messages, they are sorted by next_attempt */
+    }
+    if (NULL != pos->qe)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "not eligible\n");
+      continue;   /* not eligible */
+    }
+    sc->consideration_counter++;
+    /* determine if we have to fragment, if so add fragmentation
+       overhead! */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "check %" PRIu64 " for sc->best\n",
+                pos->logging_uuid);
+    frag = GNUNET_NO;
+    if (((0 != queue->mtu) &&
+         (pos->bytes_msg + real_overhead > queue->mtu)) ||
+        (pos->bytes_msg > UINT16_MAX - sizeof(struct
+                                              GNUNET_TRANSPORT_SendMessageTo))
+        ||
+        (NULL != pos->head_frag /* fragments already exist, should
+                                     respect that even if MTU is UINT16_MAX for
+                                     this queue */))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "fragment msg with size %u, realoverhead is %lu\n",
+                  pos->bytes_msg,
+                  real_overhead);
+      frag = GNUNET_YES;
+      if (GNUNET_TRANSPORT_CC_RELIABLE == queue->tc->details.communicator.cc)
+      {
+        /* FIXME-FRAG-REL-UUID: we could use an optimized, shorter fragmentation
+           header without the ACK UUID when using a *reliable* channel! */
+      }
+      real_overhead = overhead + sizeof(struct TransportFragmentBoxMessage);
+    }
+    /* determine if we have to reliability-box, if so add reliability box
+       overhead */
+    relb = GNUNET_NO;
+    if ((GNUNET_NO == frag) &&
+        (0 == (pos->prefs & GNUNET_MQ_PREF_UNRELIABLE)) &&
+        (GNUNET_TRANSPORT_CC_RELIABLE != queue->tc->details.communicator.cc))
+    {
+      real_overhead += sizeof(struct TransportReliabilityBoxMessage);
+
+      if ((0 != queue->mtu) && (pos->bytes_msg + real_overhead > queue->mtu))
+      {
+        frag = GNUNET_YES;
+        real_overhead = overhead + sizeof(struct TransportFragmentBoxMessage);
+      }
+      else
+      {
+        relb = GNUNET_YES;
+      }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Create reliability box of msg with size %u, realoverhead is %lu %u %u %u\n",
+                  pos->bytes_msg,
+                  real_overhead,
+                  queue->mtu,
+                  frag,
+                  relb);
+    }
+
+    /* Finally, compare to existing 'best' in sc to see if this 'pos' pending
+       message would beat it! */
+    if (GNUNET_NO == sc->frags_in_flight && NULL != sc->best)
+    {
+      /* CHECK if pos fits queue BETTER (=smaller) than pm, if not: continue;
+         OPTIMIZE-ME: This is a heuristic, which so far has NOT been
+         experimentally validated. There may be some huge potential for
+         improvement here. Also, we right now only compare how well the
+         given message fits _this_ queue, and do not consider how well other
+         queues might suit the message. Taking other queues into consideration
+         may further improve the result, but could also be expensive
+         in terms of CPU time.  */
+      long long sc_score = sc->frag * 40 + sc->relb * 20 + sc->real_overhead;
+      long long pm_score = frag * 40 + relb * 20 + real_overhead;
+      long long time_delta =
+        (sc->best->next_attempt.abs_value_us - pos->next_attempt.abs_value_us)
+        / 1000LL;
+
+      /* "time_delta" considers which message has been 'ready' for transmission
+         for longer, if a message has a preference for low latency, increase
+         the weight of the time_delta by 10x if it is favorable for that message */
+      if ((0 != (pos->prefs & GNUNET_MQ_PREF_LOW_LATENCY)) &&
+          (0 != (sc->best->prefs & GNUNET_MQ_PREF_LOW_LATENCY)))
+        time_delta *= 10;     /* increase weight (always, both are low latency) */
+      else if ((0 != (pos->prefs & GNUNET_MQ_PREF_LOW_LATENCY)) &&
+               (time_delta > 0))
+        time_delta *= 10;     /* increase weight, favors 'pos', which is low latency */
+      else if ((0 != (sc->best->prefs & GNUNET_MQ_PREF_LOW_LATENCY)) &&
+               (time_delta < 0))
+        time_delta *= 10;     /* increase weight, favors 'sc->best', which is low latency */
+      if (0 != queue->mtu)
+      {
+        /* Grant bonus if we are below MTU, larger bonus the closer we will
+           be to the MTU */
+        if (queue->mtu > sc->real_overhead + sc->best->bytes_msg)
+          sc_score -= queue->mtu - (sc->real_overhead + sc->best->bytes_msg);
+        if (queue->mtu > real_overhead + pos->bytes_msg)
+          pm_score -= queue->mtu - (real_overhead + pos->bytes_msg);
+      }
+      if (sc_score + time_delta > pm_score)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "sc_score of %" PRIu64 " larger, keep sc->best %" PRIu64
+                    "\n",
+                    pos->logging_uuid,
+                    sc->best->logging_uuid);
+        continue;     /* sc_score larger, keep sc->best */
+      }
+    }
+    sc->best = pos;
+    sc->dvh = dvh;
+    sc->frag = frag;
+    sc->relb = relb;
+    sc->real_overhead = real_overhead;
+  }
+}
+
+
+/**
+ * Function to call to further operate on the now DV encapsulated
+ * message @a hdr, forwarding it via @a next_hop under respect of
+ * @a options.
+ *
+ * @param cls a `struct PendingMessageScoreContext`
+ * @param next_hop next hop of the DV path
+ * @param hdr encapsulated message, technically a `struct TransportDVBoxMessage`
+ * @param options options of the original message
+ */
+static void
+extract_box_cb (void *cls,
+                struct Neighbour *next_hop,
+                const struct GNUNET_MessageHeader *hdr,
+                enum RouteMessageOptions options)
+{
+  struct PendingMessageScoreContext *sc = cls;
+  struct PendingMessage *pm = sc->best;
+  struct PendingMessage *bpm;
+  uint16_t bsize = ntohs (hdr->size);
+
+  GNUNET_assert (NULL == pm->bpm);
+  bpm = GNUNET_malloc (sizeof(struct PendingMessage) + bsize);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "5 created pm %p storing vl %p from pm %p\n",
+              bpm,
+              pm->vl,
+              pm);
+  bpm->logging_uuid = logging_uuid_gen++;
+  bpm->pmt = PMT_DV_BOX;
+  bpm->vl = pm->vl;
+  bpm->timeout = pm->timeout;
+  bpm->bytes_msg = bsize;
+  bpm->frag_parent = pm;
+  set_pending_message_uuid (bpm);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Creating DV Box %" PRIu64 " for original message %" PRIu64
+              " (next hop is %s)\n",
+              bpm->logging_uuid,
+              pm->logging_uuid,
+              GNUNET_i2s (&next_hop->pid));
+  memcpy (&bpm[1], hdr, bsize);
+  pm->bpm = bpm;
+}
+
+
+/**
+ * We believe we are ready to transmit a `struct PendingMessage` on a
+ * queue, the big question is which one!  We need to see if there is
+ * one pending that is allowed by flow control and congestion control
+ * and (ideally) matches our queue's performance profile.
+ *
+ * If such a message is found, we give the message to the communicator
+ * for transmission (updating the tracker, and re-scheduling ourselves
+ * if applicable).
+ *
+ * If no such message is found, the queue's `idle` field must be set
+ * to #GNUNET_YES.
+ *
+ * @param cls the `struct Queue` to process transmissions for
+ */
+static void
+transmit_on_queue (void *cls)
+{
+  struct Queue *queue = cls;
+  struct Neighbour *n = queue->neighbour;
+  struct PendingMessageScoreContext sc;
+  struct PendingMessage *pm;
+
+  queue->transmit_task = NULL;
+  if (NULL == n->vl)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Virtual link `%s' is down, cannot have PM for queue `%s'\n",
+                GNUNET_i2s (&n->pid),
+                queue->address);
+    queue->idle = GNUNET_YES;
+    return;
+  }
+  memset (&sc, 0, sizeof(sc));
+  select_best_pending_from_link (&sc, queue, n->vl, NULL, 0);
+  if (NULL == sc.best)
+  {
+    /* Also look at DVH that have the n as first hop! */
+    for (struct DistanceVectorHop *dvh = n->dv_head; NULL != dvh;
+         dvh = dvh->next_neighbour)
+    {
+      select_best_pending_from_link (&sc,
+                                     queue,
+                                     dvh->dv->vl,
+                                     dvh,
+                                     sizeof(struct GNUNET_PeerIdentity)
+                                     * (1 + dvh->distance)
+                                     + sizeof(struct TransportDVBoxMessage)
+                                     + sizeof(struct TransportDVBoxPayloadP));
+    }
+  }
+  if (NULL == sc.best)
+  {
+    /* no message pending, nothing to do here! */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No pending messages, queue `%s' to %s now idle\n",
+                queue->address,
+                GNUNET_i2s (&n->pid));
+    if (GNUNET_YES == sc.to_early)
+      schedule_transmit_on_queue (sc.to_early_retry_delay,
+                                  queue,
+                                  GNUNET_SCHEDULER_PRIORITY_DEFAULT);
+    queue->idle = GNUNET_YES;
+    return;
+  }
+  /* There is a message pending, we are certainly not idle */
+  queue->idle = GNUNET_NO;
+
+  /* Given selection in `sc`, do transmission */
+  pm = sc.best;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Selected message <%" PRIu64 ">\n",
+              pm->logging_uuid);
+  if (NULL != sc.dvh)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Is this %u a DV box?\n",
+                pm->pmt);
+    GNUNET_assert (PMT_DV_BOX != pm->pmt);
+    if ((NULL != sc.best->bpm) && (sc.best->bpm->used_dvh != sc.dvh))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Discard old box, because we have a new DV path.\n");
+      free_pending_message (sc.best->bpm);
+      sc.best->bpm = NULL;
+    }
+
+    if (NULL == sc.best->bpm)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "encapsulate_for_dv 2\n");
+      encapsulate_for_dv (sc.dvh->dv,
+                          1,
+                          &sc.dvh,
+                          (const struct GNUNET_MessageHeader *) &sc.best[1],
+                          &extract_box_cb,
+                          &sc,
+                          RMO_NONE,
+                          GNUNET_NO);
+      GNUNET_assert (NULL != sc.best->bpm);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "%lu %lu %lu %lu %u\n",
+                  sizeof(struct GNUNET_PeerIdentity),
+                  sizeof(struct TransportDVBoxMessage),
+                  sizeof(struct TransportDVBoxPayloadP),
+                  sizeof(struct TransportFragmentBoxMessage),
+                  ((const struct GNUNET_MessageHeader *) &sc.best[1])->size);
+      sc.best->bpm->used_dvh = sc.dvh;
+    }
+    pm = sc.best->bpm;
+  }
+  if (GNUNET_YES == sc.frag)
+  {
+    pm = fragment_message (queue, sc.dvh, pm);
+    if (NULL == pm)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Fragmentation failed queue %s to %s for <%" PRIu64
+                  ">, trying again\n",
+                  queue->address,
+                  GNUNET_i2s (&n->pid),
+                  sc.best->logging_uuid);
+      schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
+                                  queue,
+                                  GNUNET_SCHEDULER_PRIORITY_DEFAULT);
+      return;
+    }
+  }
+  else if (GNUNET_YES == sc.relb)
+  {
+    pm = reliability_box_message (queue, sc.dvh, pm);
+    if (NULL == pm)
+    {
+      /* Reliability boxing failed, try next message... */
+      GNUNET_log (
+        GNUNET_ERROR_TYPE_DEBUG,
+        "Reliability boxing failed queue %s to %s for <%" PRIu64
+        ">, trying again\n",
+        queue->address,
+        GNUNET_i2s (&n->pid),
+        sc.best->logging_uuid);
+      schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
+                                  queue,
+                                  GNUNET_SCHEDULER_PRIORITY_DEFAULT);
+      return;
+    }
+  }
+
+  /* Pass 'pm' for transission to the communicator */
+  GNUNET_log (
+    GNUNET_ERROR_TYPE_DEBUG,
+    "Passing message <%" PRIu64
+    "> to queue %s for peer %s (considered %u others)\n",
+    pm->logging_uuid,
+    queue->address,
+    GNUNET_i2s (&n->pid),
+    sc.consideration_counter);
+
+  /* Flow control: increment amount of traffic sent; if we are routing
+     via DV (and thus the ultimate target of the pending message is for
+     a different virtual link than the one of the queue), then we need
+     to use up not only the window of the direct link but also the
+     flow control window for the DV link! */
+  pm->vl->outbound_fc_window_size_used += pm->bytes_msg;
+
+  if (pm->vl != queue->neighbour->vl)
+  {
+    /* If the virtual link of the queue differs, this better be distance
+       vector routing! */
+    GNUNET_assert (NULL != sc.dvh);
+    /* If we do distance vector routing, we better not do this for a
+       message that was itself DV-routed */
+    GNUNET_assert (PMT_DV_BOX != sc.best->pmt);
+    /* We use the size of the unboxed message here, to avoid counting
+       the DV-Box header which is eaten up on the way by intermediaries */
+    queue->neighbour->vl->outbound_fc_window_size_used += sc.best->bytes_msg;
+  }
+  else
+  {
+    GNUNET_assert (NULL == sc.dvh);
+  }
+
+  queue_send_msg (queue, pm, &pm[1], pm->bytes_msg);
+
+  /* Check if this transmission somehow conclusively finished handing 'pm'
+     even without any explicit ACKs */
+  if ((PMT_CORE == pm->pmt) ||
+      (GNUNET_TRANSPORT_CC_RELIABLE == queue->tc->details.communicator.cc))
+  {
+    completed_pending_message (pm);
+  }
+  else
+  {
+    struct GNUNET_TIME_Relative wait_duration;
+    unsigned int wait_multiplier;
+
+    if (PMT_FRAGMENT_BOX == pm->pmt)
+    {
+      struct PendingMessage *root;
+
+      root = pm->frag_parent;
+      while (NULL != root->frag_parent && PMT_DV_BOX != root->pmt)
+        root = root->frag_parent;
+
+      wait_multiplier =  (unsigned int) ceil ((double) root->bytes_msg
+                                              / ((double) root->frag_off
+                                                 / (double) root->frag_count))
+                        * 4;
+    }
+    else
+    {
+      // No fragments, we use 4 RTT before retransmitting.
+      wait_multiplier = 4;
+    }
+
+    // Depending on how much pending message the VirtualLink is queueing, we wait longer.
+    // wait_multiplier = wait_multiplier * pm->vl->pending_msg_num;
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Wait multiplier %u\n",
+                wait_multiplier);
+
+    /* Message not finished, waiting for acknowledgement.
+       Update time by which we might retransmit 's' based on queue
+       characteristics (i.e. RTT); it takes one RTT for the message to
+       arrive and the ACK to come back in the best case; but the other
+       side is allowed to delay ACKs by 2 RTTs, so we use 4 RTT before
+       retransmitting.
+
+       OPTIMIZE: Note that in the future this heuristic should likely
+       be improved further (measure RTT stability, consider message
+       urgency and size when delaying ACKs, etc.) */
+
+    if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us !=
+        queue->pd.aged_rtt.rel_value_us)
+      wait_duration = queue->pd.aged_rtt;
+    else
+    {
+      wait_duration = DEFAULT_ACK_WAIT_DURATION;
+      wait_multiplier = 4;
+    }
+    struct GNUNET_TIME_Absolute next = GNUNET_TIME_relative_to_absolute (
+      GNUNET_TIME_relative_multiply (
+        wait_duration, wait_multiplier));
+    struct GNUNET_TIME_Relative plus = GNUNET_TIME_relative_multiply (
+      wait_duration, wait_multiplier);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Waiting %s for ACK until %s\n",
+                GNUNET_STRINGS_relative_time_to_string (plus, GNUNET_NO),
+                GNUNET_STRINGS_absolute_time_to_string (next));
+    update_pm_next_attempt (pm,
+                            GNUNET_TIME_relative_to_absolute (
+                              GNUNET_TIME_relative_multiply (wait_duration,
+                                                             wait_multiplier)));
+  }
+  /* finally, re-schedule queue transmission task itself */
+  schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
+                              queue,
+                              GNUNET_SCHEDULER_PRIORITY_DEFAULT);
+}
+
+
+/**
+ * Queue to a peer went down.  Process the request.
+ *
+ * @param cls the client
+ * @param dqm the send message that was sent
+ */
+static void
+handle_del_queue_message (void *cls,
+                          const struct GNUNET_TRANSPORT_DelQueueMessage *dqm)
+{
+  struct TransportClient *tc = cls;
+
+  if (CT_COMMUNICATOR != tc->type)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (tc->client);
+    return;
+  }
+  for (struct Queue *queue = tc->details.communicator.queue_head; NULL != queue;
+       queue = queue->next_client)
+  {
+    struct Neighbour *neighbour = queue->neighbour;
+
+    if ((ntohl (dqm->qid) != queue->qid) ||
+        (0 != GNUNET_memcmp (&dqm->receiver, &neighbour->pid)))
+      continue;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Dropped queue %s to peer %s\n",
+                queue->address,
+                GNUNET_i2s (&neighbour->pid));
+    free_queue (queue);
+    GNUNET_SERVICE_client_continue (tc->client);
+    return;
+  }
+  GNUNET_break (0);
+  GNUNET_SERVICE_client_drop (tc->client);
+}
+
+
+static void
+free_queue_entry (struct QueueEntry *qe,
+                  struct TransportClient *tc)
+{
+  struct PendingMessage *pm;
+
+  GNUNET_CONTAINER_DLL_remove (qe->queue->queue_head,
+                               qe->queue->queue_tail,
+                               qe);
+  qe->queue->queue_length--;
+  tc->details.communicator.total_queue_length--;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received ACK on queue %s (QID %u) to peer %s (new length: %u/%u)\n",
+              qe->queue->address,
+              qe->queue->qid,
+              GNUNET_i2s (&qe->queue->neighbour->pid),
+              qe->queue->queue_length,
+              tc->details.communicator.total_queue_length);
+
+  /* if applicable, resume transmissions that waited on ACK */
+  if (COMMUNICATOR_TOTAL_QUEUE_LIMIT - 1 ==
+      tc->details.communicator.total_queue_length)
+  {
+    /* Communicator dropped below threshold, resume all queues
+       incident with this client! */
+    GNUNET_STATISTICS_update (
+      GST_stats,
+      "# Transmission throttled due to communicator queue limit",
+      -1,
+      GNUNET_NO);
+    for (struct Queue *queue = tc->details.communicator.queue_head;
+         NULL != queue;
+         queue = queue->next_client)
+    {
+      schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
+                                  queue,
+                                  GNUNET_SCHEDULER_PRIORITY_DEFAULT);
+    }
+  }
+  else if (QUEUE_LENGTH_LIMIT - 1 == qe->queue->queue_length)
+  {
+    /* queue dropped below threshold; only resume this one queue */
+    GNUNET_STATISTICS_update (GST_stats,
+                              "# Transmission throttled due to queue queue limit",
+                              -1,
+                              GNUNET_NO);
+    schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
+                                qe->queue,
+                                GNUNET_SCHEDULER_PRIORITY_DEFAULT);
+  }
+  else if (1 == qe->queue->q_capacity)
+  {
+    // TODO I guess this will never happen, because the communicator triggers this by updating its queue length itself.
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmission rescheduled due to communicator message queue with qid %u has capacity %"
+                PRIu64 ".\n",
+                qe->queue->qid,
+                qe->queue->q_capacity);
+    /* message queue has capacity; only resume this one queue */
+    /* queue dropped below threshold; only resume this one queue */
+    GNUNET_STATISTICS_update (GST_stats,
+                              "# Transmission throttled due to message queue capacity",
+                              -1,
+                              GNUNET_NO);
+    schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
+                                qe->queue,
+                                GNUNET_SCHEDULER_PRIORITY_DEFAULT);
+  }
+
+  if (NULL != (pm = qe->pm))
+  {
+    struct VirtualLink *vl;
+
+    // GNUNET_assert (qe == pm->qe);
+    pm->qe = NULL;
+    /* If waiting for this communicator may have blocked transmission
+       of pm on other queues for this neighbour, force schedule
+       transmit on queue for queues of the neighbour */
+    if (NULL == pm->frag_parent)
+    {
+      vl = pm->vl;
+      if ((NULL != vl) &&
+          (NULL != vl->pending_msg_head) &&
+          (vl->pending_msg_head == pm))
+        check_vl_transmission (vl);
+    }
+  }
+  GNUNET_free (qe);
+}
+
+
+/**
+ * Message was transmitted.  Process the request.
+ *
+ * @param cls the client
+ * @param sma the send message that was sent
+ */
+static void
+handle_send_message_ack (void *cls,
+                         const struct GNUNET_TRANSPORT_SendMessageToAck *sma)
+{
+  struct TransportClient *tc = cls;
+  struct QueueEntry *qe;
+
+  if (CT_COMMUNICATOR != tc->type)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (tc->client);
+    return;
+  }
+
+  /* find our queue entry matching the ACK */
+  qe = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Looking for queue for PID %s\n",
+              GNUNET_i2s (&sma->receiver));
+  for (struct Queue *queue = tc->details.communicator.queue_head; NULL != queue;
+       queue = queue->next_client)
+  {
+    if (0 != GNUNET_memcmp (&queue->neighbour->pid, &sma->receiver))
+      continue;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Found PID %s\n",
+                GNUNET_i2s (&queue->neighbour->pid));
+
+
+    for (struct QueueEntry *qep = queue->queue_head; NULL != qep;
+         qep = qep->next)
+    {
+      if (qep->mid != GNUNET_ntohll (sma->mid) || queue->qid != ntohl (
+            sma->qid))
+        continue;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "QueueEntry MID: %" PRIu64 " on queue QID: %u, Ack MID: %"
+                  PRIu64 " Ack QID %u\n",
+                  qep->mid,
+                  queue->qid,
+                  GNUNET_ntohll (sma->mid),
+                  ntohl (sma->qid));
+      qe = qep;
+      if ((NULL != qe->pm) && (qe->pm->qe != qe))
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "For pending message %" PRIu64 " we had retransmissions.\n",
+                    qe->pm->logging_uuid);
+      break;
+    }
+  }
+  if (NULL == qe)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No QueueEntry found for Ack MID %" PRIu64 " QID: %u\n",
+                GNUNET_ntohll (sma->mid),
+                ntohl (sma->qid));
+    // TODO I guess this can happen, if the Ack from the peer comes before the Ack from the queue.
+    // Update: Maybe QueueEntry was accidentally freed during freeing PendingMessage.
+    /* this should never happen */
+    // GNUNET_break (0);
+    // GNUNET_SERVICE_client_drop (tc->client);
+    GNUNET_SERVICE_client_continue (tc->client);
+    return;
+  }
+  free_queue_entry (qe, tc);
+  GNUNET_SERVICE_client_continue (tc->client);
+}
+
+
+/**
+ * Iterator telling new MONITOR client about all existing
+ * queues to peers.
+ *
+ * @param cls the new `struct TransportClient`
+ * @param pid a connected peer
+ * @param value the `struct Neighbour` with more information
+ * @return #GNUNET_OK (continue to iterate)
+ */
+static int
+notify_client_queues (void *cls,
+                      const struct GNUNET_PeerIdentity *pid,
+                      void *value)
+{
+  struct TransportClient *tc = cls;
+  struct Neighbour *neighbour = value;
+
+  GNUNET_assert (CT_MONITOR == tc->type);
+  for (struct Queue *q = neighbour->queue_head; NULL != q;
+       q = q->next_neighbour)
+  {
+    struct MonitorEvent me = { .rtt = q->pd.aged_rtt,
+                               .cs = q->cs,
+                               .num_msg_pending = q->num_msg_pending,
+                               .num_bytes_pending = q->num_bytes_pending };
+
+    notify_monitor (tc, pid, q->address, q->nt, &me);
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Initialize a monitor client.
+ *
+ * @param cls the client
+ * @param start the start message that was sent
+ */
+static void
+handle_monitor_start (void *cls,
+                      const struct GNUNET_TRANSPORT_MonitorStart *start)
+{
+  struct TransportClient *tc = cls;
+
+  if (CT_NONE != tc->type)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (tc->client);
+    return;
+  }
+  tc->type = CT_MONITOR;
+  tc->details.monitor.peer = start->peer;
+  tc->details.monitor.one_shot = ntohl (start->one_shot);
+  GNUNET_CONTAINER_multipeermap_iterate (neighbours, &notify_client_queues, tc);
+  GNUNET_SERVICE_client_mark_monitor (tc->client);
+  GNUNET_SERVICE_client_continue (tc->client);
+}
+
+
+/**
+ * Find transport client providing communication service
+ * for the protocol @a prefix.
+ *
+ * @param prefix communicator name
+ * @return NULL if no such transport client is available
+ */
+static struct TransportClient *
+lookup_communicator (const char *prefix)
+{
+  for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
+  {
+    if (CT_COMMUNICATOR != tc->type)
+      continue;
+    if (0 == strcmp (prefix, tc->details.communicator.address_prefix))
+      return tc;
+  }
+  GNUNET_log (
+    GNUNET_ERROR_TYPE_WARNING,
+    "Somone suggested use of communicator for `%s', but we do not have such a communicator!\n",
+    prefix);
+  return NULL;
+}
+
+
+/**
+ * Signature of a function called with a communicator @a address of a peer
+ * @a pid that an application wants us to connect to.
+ *
+ * @param pid target peer
+ * @param address the address to try
+ */
+static void
+suggest_to_connect (const struct GNUNET_PeerIdentity *pid, const char *address)
+{
+  static uint32_t idgen;
+  struct TransportClient *tc;
+  char *prefix;
+  struct GNUNET_TRANSPORT_CreateQueue *cqm;
+  struct GNUNET_MQ_Envelope *env;
+  size_t alen;
+
+  prefix = GNUNET_HELLO_address_to_prefix (address);
+  if (NULL == prefix)
+  {
+    GNUNET_break (0);  /* We got an invalid address!? */
+    return;
+  }
+  tc = lookup_communicator (prefix);
+  if (NULL == tc)
+  {
+    GNUNET_STATISTICS_update (GST_stats,
+                              "# Suggestions ignored due to missing communicator",
+                              1,
+                              GNUNET_NO);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Cannot connect to %s at `%s', no matching communicator present\n",
+                GNUNET_i2s (pid),
+                address);
+    GNUNET_free (prefix);
+    return;
+  }
+  /* forward suggestion for queue creation to communicator */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Request #%u for `%s' communicator to create queue to `%s' at `%s'\n",
+              (unsigned int) idgen,
+              prefix,
+              GNUNET_i2s (pid),
+              address);
+  GNUNET_free (prefix);
+  alen = strlen (address) + 1;
+  env =
+    GNUNET_MQ_msg_extra (cqm, alen, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE);
+  cqm->request_id = htonl (idgen++);
+  cqm->receiver = *pid;
+  memcpy (&cqm[1], address, alen);
+  GNUNET_MQ_send (tc->mq, env);
+}
+
+
+/**
+ * The queue @a q (which matches the peer and address in @a vs) is
+ * ready for queueing. We should now queue the validation request.
+ *
+ * @param q queue to send on
+ * @param vs state to derive validation challenge from
+ */
+static void
+validation_transmit_on_queue (struct Queue *q, struct ValidationState *vs)
+{
+  struct TransportValidationChallengeMessage tvc;
+  struct GNUNET_TIME_Absolute monotonic_time;
+
+  if (NULL != vs->revalidation_task)
+  {
+    GNUNET_SCHEDULER_cancel (vs->revalidation_task);
+    vs->revalidation_task = NULL;
+  }
+  /*memcpy (&hkey,
+          &hc,
+          sizeof (hkey));*/
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Remove key %s for address %s map size %u contains %u\n",
+              GNUNET_h2s (&vs->hc),
+              vs->address,
+              GNUNET_CONTAINER_multihashmap_size (revalidation_map),
+              GNUNET_CONTAINER_multihashmap_contains (revalidation_map,
+                                                      &vs->hc));
+  GNUNET_CONTAINER_multihashmap_remove (revalidation_map, &vs->hc, vs);
+
+  monotonic_time  = GNUNET_TIME_absolute_get_monotonic (GST_cfg);
+  if (GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us ==
+      vs->last_challenge_use.abs_value_us)
+  {
+    vs->first_challenge_use = monotonic_time;
+  }
+  vs->last_challenge_use = monotonic_time;
+  tvc.header.type =
+    htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE);
+  tvc.header.size = htons (sizeof(tvc));
+  tvc.reserved = htonl (0);
+  tvc.challenge = vs->challenge;
+  tvc.sender_time = GNUNET_TIME_absolute_hton (vs->last_challenge_use);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Sending address validation challenge %s to %s\n",
+              GNUNET_sh2s (&tvc.challenge.value),
+              GNUNET_i2s (&q->neighbour->pid));
+  queue_send_msg (q, NULL, &tvc, sizeof(tvc));
+}
+
+
+/**
+ * Task run periodically to validate some address based on #validation_heap.
+ *
+ * @param cls NULL
+ */
+static void
+validation_start_cb (void *cls)
+{
+  struct ValidationState *vs;
+  struct Queue *q;
+  const struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get_monotonic (
+    GST_cfg);
+
+  (void) cls;
+  validation_task = NULL;
+  vs = GNUNET_CONTAINER_heap_peek (validation_heap);
+  /* drop validations past their expiration */
+  while (
+    (NULL != vs) &&
+    (0 == GNUNET_TIME_absolute_get_remaining (vs->valid_until).rel_value_us))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Validation response %s cleaned up\n",
+                GNUNET_sh2s (&vs->challenge.value));
+    free_validation_state (vs);
+    vs = GNUNET_CONTAINER_heap_peek (validation_heap);
+  }
+  if (NULL == vs)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Address validation task not scheduled anymore, nothing to do\n");
+    return;   /* woopsie, no more addresses known, should only
+                 happen if we're really a lonely peer */
+  }
+  q = find_queue (&vs->pid, vs->address);
+  if (GNUNET_TIME_absolute_cmp (vs->first_challenge_use, >, now))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "To early to start next address validation for challenge %s\n",
+                GNUNET_sh2s (&vs->challenge.value));
+    return;
+  }
+  if (NULL == q)
+  {
+    vs->awaiting_queue = GNUNET_YES;
+    suggest_to_connect (&vs->pid, vs->address);
+  }
+  else
+    validation_transmit_on_queue (q, vs);
+  /* Finally, reschedule next attempt */
+  vs->challenge_backoff =
+    GNUNET_TIME_randomized_backoff (vs->challenge_backoff,
+                                    MAX_VALIDATION_CHALLENGE_FREQ);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Address validation task will run again in %s\n",
+              GNUNET_STRINGS_relative_time_to_string (vs->challenge_backoff,
+                                                      GNUNET_YES));
+  update_next_challenge_time (vs,
+                              GNUNET_TIME_relative_to_absolute (
+                                vs->challenge_backoff));
+}
+
+
+/**
+ * Closure for #check_connection_quality.
+ */
+struct QueueQualityContext
+{
+  /**
+   * Set to the @e k'th queue encountered.
+   */
+  struct Queue *q;
+
+  /**
+   * Set to the number of quality queues encountered.
+   */
+  unsigned int quality_count;
+
+  /**
+   * Set to the total number of queues encountered.
+   */
+  unsigned int num_queues;
+
+  /**
+   * Decremented for each queue, for selection of the
+   * k-th queue in @e q.
+   */
+  unsigned int k;
+};
+
+
+/**
+ * Check whether any queue to the given neighbour is
+ * of a good "quality" and if so, increment the counter.
+ * Also counts the total number of queues, and returns
+ * the k-th queue found.
+ *
+ * @param cls a `struct QueueQualityContext *` with counters
+ * @param pid peer this is about
+ * @param value a `struct Neighbour`
+ * @return #GNUNET_OK (continue to iterate)
+ */
+static int
+check_connection_quality (void *cls,
+                          const struct GNUNET_PeerIdentity *pid,
+                          void *value)
+{
+  struct QueueQualityContext *ctx = cls;
+  struct Neighbour *n = value;
+  int do_inc;
+
+  (void) pid;
+  do_inc = GNUNET_NO;
+  for (struct Queue *q = n->queue_head; NULL != q; q = q->next_neighbour)
+  {
+    ctx->num_queues++;
+    if (0 == ctx->k--)
+      ctx->q = q;
+    /* FIXME-CONQ-STATISTICS: in the future, add reliability / goodput
+       statistics and consider those as well here? */
+    if (q->pd.aged_rtt.rel_value_us < DV_QUALITY_RTT_THRESHOLD.rel_value_us)
+      do_inc = GNUNET_YES;
+  }
+  if (GNUNET_YES == do_inc)
+    ctx->quality_count++;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Task run when we CONSIDER initiating a DV learn
+ * process. We first check that sending out a message is
+ * even possible (queues exist), then that it is desirable
+ * (if not, reschedule the task for later), and finally
+ * we may then begin the job.  If there are too many
+ * entries in the #dvlearn_map, we purge the oldest entry
+ * using #lle_tail.
+ *
+ * @param cls NULL
+ */
+static void
+start_dv_learn (void *cls)
+{
+  struct LearnLaunchEntry *lle;
+  struct QueueQualityContext qqc;
+  struct TransportDVLearnMessage dvl;
+
+  (void) cls;
+  dvlearn_task = NULL;
+  if (0 == GNUNET_CONTAINER_multipeermap_size (neighbours))
+    return; /* lost all connectivity, cannot do learning */
+  qqc.quality_count = 0;
+  qqc.num_queues = 0;
+  qqc.k = GNUNET_CONTAINER_multipeermap_size (neighbours);
+  GNUNET_CONTAINER_multipeermap_iterate (neighbours,
+                                         &check_connection_quality,
+                                         &qqc);
+  if (qqc.quality_count > DV_LEARN_QUALITY_THRESHOLD)
+  {
+    struct GNUNET_TIME_Relative delay;
+    unsigned int factor;
+
+    /* scale our retries by how far we are above the threshold */
+    factor = qqc.quality_count / DV_LEARN_QUALITY_THRESHOLD;
+    delay = GNUNET_TIME_relative_multiply (DV_LEARN_BASE_FREQUENCY, factor);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "At connection quality %u, will launch DV learn in %s\n",
+                qqc.quality_count,
+                GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES));
+    dvlearn_task = GNUNET_SCHEDULER_add_delayed (delay, &start_dv_learn, NULL);
+    return;
+  }
+  /* remove old entries in #dvlearn_map if it has grown too big */
+  while (MAX_DV_LEARN_PENDING <=
+         GNUNET_CONTAINER_multishortmap_size (dvlearn_map))
+  {
+    lle = lle_tail;
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multishortmap_remove (dvlearn_map,
+                                                          &lle->challenge.value,
+                                                          lle));
+    GNUNET_CONTAINER_DLL_remove (lle_head, lle_tail, lle);
+    GNUNET_free (lle);
+  }
+  /* setup data structure for learning */
+  lle = GNUNET_new (struct LearnLaunchEntry);
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE,
+                              &lle->challenge,
+                              sizeof(lle->challenge));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Starting launch DV learn with challenge %s\n",
+              GNUNET_sh2s (&lle->challenge.value));
+  GNUNET_CONTAINER_DLL_insert (lle_head, lle_tail, lle);
+  GNUNET_break (GNUNET_YES ==
+                GNUNET_CONTAINER_multishortmap_put (
+                  dvlearn_map,
+                  &lle->challenge.value,
+                  lle,
+                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  dvl.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_DV_LEARN);
+  dvl.header.size = htons (sizeof(dvl));
+  dvl.num_hops = htons (0);
+  dvl.bidirectional = htons (0);
+  dvl.non_network_delay = GNUNET_TIME_relative_hton (GNUNET_TIME_UNIT_ZERO);
+  dvl.monotonic_time =
+    GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (GST_cfg));
+  {
+    struct DvInitPS dvip = {
+      .purpose.purpose = htonl (
+        GNUNET_SIGNATURE_PURPOSE_TRANSPORT_DV_INITIATOR),
+      .purpose.size = htonl (sizeof(dvip)),
+      .monotonic_time = dvl.monotonic_time,
+      .challenge = lle->challenge
+    };
+
+    GNUNET_CRYPTO_eddsa_sign (GST_my_private_key,
+                              &dvip,
+                              &dvl.init_sig);
+  }
+  dvl.initiator = GST_my_identity;
+  dvl.challenge = lle->challenge;
+
+  qqc.quality_count = 0;
+  qqc.k = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, qqc.num_queues);
+  qqc.num_queues = 0;
+  qqc.q = NULL;
+  GNUNET_CONTAINER_multipeermap_iterate (neighbours,
+                                         &check_connection_quality,
+                                         &qqc);
+  GNUNET_assert (NULL != qqc.q);
+
+  /* Do this as close to transmission time as possible! */
+  lle->launch_time = GNUNET_TIME_absolute_get ();
+
+  queue_send_msg (qqc.q, NULL, &dvl, sizeof(dvl));
+  /* reschedule this job, randomizing the time it runs (but no
+     actual backoff!) */
+  dvlearn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_randomize (
+                                                 DV_LEARN_BASE_FREQUENCY),
+                                               &start_dv_learn,
+                                               NULL);
+}
+
+
+/**
+ * Get the IP address without the port number.
+ *
+ * @param address The string contains a communicator prefix, IP address and port
+ *        like this 'tcp-92.68.150.1:55452'.
+ * @return String with IP address only.
+ */
+static char *
+get_address_without_port (const char *address)
+{
+  const char *colon;
+  char *colon_rest;
+  size_t colon_rest_length;
+  char *address_without_port;
+
+  colon = strchr (address,':');
+  colon_rest = GNUNET_strndup (address, colon - address);
+  colon_rest_length = strlen (colon_rest);
+  address_without_port = GNUNET_strndup (&colon_rest[4], colon_rest_length - 4);
+  GNUNET_free (colon_rest);
+
+  return address_without_port;
+}
+
+
+/**
+ * A new queue has been created, check if any address validation
+ * requests have been waiting for it.
+ *
+ * @param cls a `struct Queue`
+ * @param pid peer concerned (unused)
+ * @param value a `struct ValidationState`
+ * @return #GNUNET_NO if a match was found and we can stop looking
+ */
+static int
+check_validation_request_pending (void *cls,
+                                  const struct GNUNET_PeerIdentity *pid,
+                                  void *value)
+{
+  struct Queue *q = cls;
+  struct ValidationState *vs = value;
+  char *address_without_port_vs;
+  char *address_without_port_q;
+  int success = GNUNET_YES;
+
+  //TODO Check if this is really necessary.
+  address_without_port_vs = get_address_without_port (vs->address);
+  address_without_port_q = get_address_without_port (q->address);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Check validation request pending for `%s' at `%s'/`%s' (vs)/(q)\n",
+              GNUNET_i2s (pid),
+              address_without_port_vs,
+              address_without_port_q);
+  (void) pid;
+  if ((GNUNET_YES == vs->awaiting_queue) &&
+      (0 == strcmp (address_without_port_vs, address_without_port_q)))
+  {
+
+    vs->awaiting_queue = GNUNET_NO;
+    validation_transmit_on_queue (q, vs);
+    success = GNUNET_NO;
+  }
+
+  GNUNET_free (address_without_port_vs);
+  GNUNET_free (address_without_port_q);
+  return success;
+}
+
+
+/**
+ * Function called with the monotonic time of a DV initiator
+ * by PEERSTORE. Updates the time.
+ *
+ * @param cls a `struct Neighbour`
+ * @param record the information found, NULL for the last call
+ * @param emsg error message
+ */
+static void
+neighbour_dv_monotime_cb (void *cls,
+                          const struct GNUNET_PEERSTORE_Record *record,
+                          const char *emsg)
+{
+  struct Neighbour *n = cls;
+  struct GNUNET_TIME_AbsoluteNBO *mtbe;
+
+  (void) emsg;
+  if (NULL == record)
+  {
+    /* we're done with #neighbour_dv_monotime_cb() invocations,
+       continue normal processing */
+    n->get = NULL;
+    n->dv_monotime_available = GNUNET_YES;
+    return;
+  }
+  if (0 == record->value_size)
+  {
+    GNUNET_PEERSTORE_iteration_next (n->get, 1);
+    GNUNET_break (0);
+    return;
+  }
+  mtbe = record->value;
+  n->last_dv_learn_monotime =
+    GNUNET_TIME_absolute_max (n->last_dv_learn_monotime,
+                              GNUNET_TIME_absolute_ntoh (*mtbe));
+  GNUNET_PEERSTORE_iteration_next (n->get, 1);
+}
+
+
+static void
+iterate_address_and_compare_cb (void *cls,
+                                const struct GNUNET_PeerIdentity *pid,
+                                const char *uri)
+{
+  struct Queue *queue = cls;
+  const char *slash;
+  char *address_uri;
+  char *prefix;
+  char *uri_without_port;
+  char *address_uri_without_port;
+
+  slash = strrchr (uri, '/');
+  prefix = GNUNET_strndup (uri, (slash - uri) - 2);
+  GNUNET_assert (NULL != slash);
+  slash++;
+  GNUNET_asprintf (&address_uri,
+                   "%s-%s",
+                   prefix,
+                   slash);
+
+  address_uri_without_port = get_address_without_port (queue->address);
+  uri_without_port = get_address_without_port (address_uri);
+  if (0 == strcmp (uri_without_port, address_uri_without_port))
+  {
+    queue->is_global_natted = GNUNET_NO;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "not global natted %u %s %s %s %s %s %u\n",
+              queue->is_global_natted,
+              uri,
+              queue->address,
+              uri_without_port,
+              address_uri_without_port,
+              prefix,
+              GNUNET_NO);
+  GNUNET_free (prefix);
+  GNUNET_free (address_uri);
+  GNUNET_free (address_uri_without_port);
+  GNUNET_free (uri_without_port);
+}
+
+
+static void
+check_for_global_natted_error_cb (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Error in PEERSTORE monitoring for checking global natted\n");
+}
+
+
+static void
+check_for_global_natted_sync_cb (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Done with initial PEERSTORE iteration during monitoring  for checking global natted\n");
+}
+
+
+struct TransportGlobalNattedAddressClosure
+{
+  /**
+   * The address to search for.
+   */
+  char *addr;
+
+  /**
+   * The struct TransportGlobalNattedAddress to set.
+   */
+  struct TransportGlobalNattedAddress *tgna;
+};
+
+
+static enum GNUNET_GenericReturnValue
+contains_address (void *cls,
+                  const struct GNUNET_PeerIdentity *pid,
+                  void *value)
+{
+  struct TransportGlobalNattedAddressClosure *tgna_cls = cls;
+  struct TransportGlobalNattedAddress *tgna = value;
+  char *addr = (char *) &tgna[1];
+
+  if (strlen(tgna_cls->addr) == ntohl (tgna->address_length)
+      && 0 == strncmp (addr, tgna_cls->addr, ntohl (tgna->address_length)))
+  {
+    tgna_cls->tgna = tgna;
+    return GNUNET_NO;
+  }
+  return GNUNET_YES;
+}
+
+
+static void
+check_for_global_natted (void *cls,
+                         const struct GNUNET_PEERSTORE_Record *record,
+                         const char *emsg)
+{
+  struct Queue *queue = cls;
+  struct Neighbour *neighbour = queue->neighbour;
+  struct GNUNET_HELLO_Builder *builder;
+  struct GNUNET_MessageHeader *hello;
+  struct TransportGlobalNattedAddressClosure tgna_cls;
+  size_t address_len_without_port;
+
+  if (NULL != emsg)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+         "Got failure from PEERSTORE: %s\n",
+         emsg);
+    return;
+  }
+  if (NULL == record)
+  {
+    queue->mo = NULL;
+    return;
+  }
+  if (0 == record->value_size)
+  {
+    GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
+    GNUNET_break (0);
+    return;
+  }
+  queue->is_global_natted = GNUNET_YES;
+  hello = record->value;
+  builder = GNUNET_HELLO_builder_from_msg (hello);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "before not global natted %u\n",
+              queue->is_global_natted);
+  GNUNET_HELLO_builder_iterate (builder,
+                                &iterate_address_and_compare_cb,
+                                queue);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "after not global natted %u\n",
+              queue->is_global_natted);
+  GNUNET_HELLO_builder_free (builder);
+
+  tgna_cls.addr = get_address_without_port (queue->address);
+  tgna_cls.tgna = NULL;
+  address_len_without_port = strlen (tgna_cls.addr);
+  GNUNET_CONTAINER_multipeermap_get_multiple (neighbour->natted_addresses,
+                                              &neighbour->pid,
+                                              &contains_address,
+                                              &tgna_cls);
+  if (NULL != tgna_cls.tgna)
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                " tgna_cls.tgna tgna %p %lu %u %u\n",
+                tgna_cls.tgna,
+                neighbour->size_of_global_addresses,
+                ntohl (tgna_cls.tgna->address_length),
+                neighbour->number_of_addresses);
+  if (NULL == tgna_cls.tgna && GNUNET_YES == queue->is_global_natted)
+  {
+    struct TransportGlobalNattedAddress *tgna;
+
+    tgna = GNUNET_malloc (sizeof (struct TransportGlobalNattedAddress) + address_len_without_port);
+    tgna->address_length = htonl (address_len_without_port);
+    GNUNET_memcpy (&tgna[1], tgna_cls.addr, address_len_without_port);
+    GNUNET_CONTAINER_multipeermap_put (neighbour->natted_addresses,
+                                       &neighbour->pid,
+                                       tgna,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+    neighbour->number_of_addresses++;
+    neighbour->size_of_global_addresses += address_len_without_port;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Created tgna %p\n",
+                tgna);
+  }
+  else if (NULL != tgna_cls.tgna && GNUNET_NO == queue->is_global_natted)
+  {
+    GNUNET_CONTAINER_multipeermap_remove (neighbour->natted_addresses,
+                                          &neighbour->pid,
+                                          tgna_cls.tgna);
+    GNUNET_assert (neighbour->size_of_global_addresses >= ntohl (tgna_cls.tgna->address_length));
+    neighbour->size_of_global_addresses -= ntohl (tgna_cls.tgna->address_length);
+    GNUNET_assert (0 < neighbour->number_of_addresses);
+    neighbour->number_of_addresses--;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "removed tgna %p\n",
+                tgna_cls.tgna);
+    GNUNET_free (tgna_cls.tgna);
+  }
+  GNUNET_free (tgna_cls.addr);
+  GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
+}
+
+
+/**
+ * New queue became available.  Process the request.
+ *
+ * @param cls the client
+ * @param aqm the send message that was sent
+ */
+static void
+handle_add_queue_message (void *cls,
+                          const struct GNUNET_TRANSPORT_AddQueueMessage *aqm)
+{
+  struct TransportClient *tc = cls;
+  struct Queue *queue;
+  struct Neighbour *neighbour;
+  struct GNUNET_TIME_Absolute validated_until = GNUNET_TIME_UNIT_ZERO_ABS;
+  const char *addr;
+  uint16_t addr_len;
+
+  if (ntohl (aqm->mtu) <= sizeof(struct TransportFragmentBoxMessage))
+  {
+    /* MTU so small as to be useless for transmissions,
+       required for #fragment_message()! */
+    GNUNET_break_op (0);
+    GNUNET_SERVICE_client_drop (tc->client);
+    return;
+  }
+  /* This may simply be a queue update */
+  for (queue = tc->details.communicator.queue_head;
+       NULL != queue;
+       queue = queue->next_client)
+  {
+    validated_until = queue->validated_until;
+    if (queue->qid != ntohl (aqm->qid))
+      continue;
+    break;
+  }
+
+  if (NULL != queue)
+  {
+    neighbour = queue->neighbour;
+  }
+  else
+  {
+    neighbour = lookup_neighbour (&aqm->receiver);
+    if (NULL == neighbour)
+    {
+      neighbour = GNUNET_new (struct Neighbour);
+      neighbour->natted_addresses = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_YES);
+      neighbour->pid = aqm->receiver;
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_CONTAINER_multipeermap_put (
+                       neighbours,
+                       &neighbour->pid,
+                       neighbour,
+                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+      neighbour->get =
+        GNUNET_PEERSTORE_iteration_start (peerstore,
+                                          "transport",
+                                          &neighbour->pid,
+                                          GNUNET_PEERSTORE_TRANSPORT_DVLEARN_MONOTIME,
+                                          &neighbour_dv_monotime_cb,
+                                          neighbour);
+    }
+    addr_len = ntohs (aqm->header.size) - sizeof(*aqm);
+    addr = (const char *) &aqm[1];
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "New queue %s to %s available with QID %u and q_len %" PRIu64
+                " and mtu %u\n",
+                addr,
+                GNUNET_i2s (&aqm->receiver),
+                ntohl (aqm->qid),
+                GNUNET_ntohll (aqm->q_len),
+                ntohl (aqm->mtu));
+    queue = GNUNET_malloc (sizeof(struct Queue) + addr_len);
+    queue->tc = tc;
+    if (GNUNET_TIME_UNIT_ZERO_ABS.abs_value_us != validated_until.abs_value_us)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "New queue with QID %u inherit validated until\n",
+                  ntohl (aqm->qid));
+      queue->validated_until = validated_until;
+    }
+    queue->address = (const char *) &queue[1];
+    queue->pd.aged_rtt = GNUNET_TIME_UNIT_FOREVER_REL;
+    queue->qid = ntohl (aqm->qid);
+    queue->neighbour = neighbour;
+    if (GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED == GNUNET_ntohll (aqm->q_len))
+      queue->unlimited_length = GNUNET_YES;
+    queue->q_capacity = GNUNET_ntohll (aqm->q_len);
+    memcpy (&queue[1], addr, addr_len);
+    /* notify monitors about new queue */
+    {
+      struct MonitorEvent me = { .rtt = queue->pd.aged_rtt, .cs = queue->cs };
+
+      notify_monitors (&neighbour->pid, queue->address, queue->nt, &me);
+    }
+    GNUNET_CONTAINER_MDLL_insert (neighbour,
+                                  neighbour->queue_head,
+                                  neighbour->queue_tail,
+                                  queue);
+    GNUNET_CONTAINER_MDLL_insert (client,
+                                  tc->details.communicator.queue_head,
+                                  tc->details.communicator.queue_tail,
+                                  queue);
+
+  }
+  queue->mtu = ntohl (aqm->mtu);
+  queue->nt = (enum GNUNET_NetworkType) ntohl (aqm->nt);
+  queue->cs = (enum GNUNET_TRANSPORT_ConnectionStatus) ntohl (aqm->cs);
+  queue->idle = GNUNET_YES;
+  queue->mo = GNUNET_PEERSTORE_monitor_start (GST_cfg,
+                                    GNUNET_YES,
+                                    "peerstore",
+                                    &neighbour->pid,
+                                    GNUNET_PEERSTORE_HELLO_KEY,
+                                    &check_for_global_natted_error_cb,
+                                    NULL,
+                                    &check_for_global_natted_sync_cb,
+                                    NULL,
+                                    &check_for_global_natted,
+                                    queue);
+  /* check if valdiations are waiting for the queue */
+  if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (validation_map,
+                                                            &aqm->receiver))
+  {
+    if (GNUNET_SYSERR != GNUNET_CONTAINER_multipeermap_get_multiple (
+          validation_map,
+          &aqm->
+          receiver,
+          &
+          check_validation_request_pending,
+          queue))
+      start_address_validation (&aqm->receiver, queue->address);
+  }
+  else
+    start_address_validation (&aqm->receiver, queue->address);
+  /* look for traffic for this queue */
+  // TODO Check whether this makes any sense at all.
+  /*schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
+    queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT);*/
+  /* might be our first queue, try launching DV learning */
+  if (NULL == dvlearn_task)
+    dvlearn_task = GNUNET_SCHEDULER_add_now (&start_dv_learn, NULL);
+  GNUNET_SERVICE_client_continue (tc->client);
+}
+
+
+/**
+ * @brief Handle updates to queues.
+ *
+ * @param cls the transport client.
+ * @param msg Message struct.
+ */
+static void
+handle_update_queue_message (void *cls,
+                             const struct
+                             GNUNET_TRANSPORT_UpdateQueueMessage *msg)
+{
+  struct TransportClient *tc = cls;
+  struct Queue *target_queue = NULL;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received queue update message for %u with q_len %llu and mtu %u\n",
+              ntohl (msg->qid),
+              (unsigned long long) GNUNET_ntohll (msg->q_len),
+              ntohl (msg->mtu));
+  for (target_queue = tc->details.communicator.queue_head;
+       NULL != target_queue;
+       target_queue = target_queue->next_client)
+  {
+    if (ntohl (msg->qid) == target_queue->qid)
+      break;
+  }
+  if (NULL == target_queue)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Queue to update no longer exists! Discarding update.\n");
+    return;
+  }
+
+  target_queue->nt = msg->nt;
+  target_queue->mtu = ntohl (msg->mtu);
+  target_queue->cs = msg->cs;
+  target_queue->priority = ntohl (msg->priority);
+  /* The update message indicates how many messages
+   * the queue should be able to handle.
+   */
+  if (GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED == GNUNET_ntohll (msg->q_len))
+    target_queue->unlimited_length = GNUNET_YES;
+  else
+    target_queue->unlimited_length = GNUNET_NO;
+  target_queue->q_capacity += GNUNET_ntohll (msg->q_len);
+  if (0 < target_queue->q_capacity)
+    schedule_transmit_on_queue (GNUNET_TIME_UNIT_ZERO,
+                                target_queue,
+                                GNUNET_SCHEDULER_PRIORITY_DEFAULT);
+  GNUNET_SERVICE_client_continue (tc->client);
+}
+
+
+/**
+ * Communicator tells us that our request to create a queue "worked", that
+ * is setting up the queue is now in process.
+ *
+ * @param cls the `struct TransportClient`
+ * @param cqr confirmation message
+ */
+static void
+handle_queue_create_ok (void *cls,
+                        const struct GNUNET_TRANSPORT_CreateQueueResponse *cqr)
+{
+  struct TransportClient *tc = cls;
+
+  if (CT_COMMUNICATOR != tc->type)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (tc->client);
+    return;
+  }
+  GNUNET_STATISTICS_update (GST_stats,
+                            "# Suggestions succeeded at communicator",
+                            1,
+                            GNUNET_NO);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Request #%u for communicator to create queue succeeded\n",
+              (unsigned int) ntohs (cqr->request_id));
+  GNUNET_SERVICE_client_continue (tc->client);
+}
+
+
+/**
+ * Communicator tells us that our request to create a queue failed. This
+ * usually indicates that the provided address is simply invalid or that the
+ * communicator's resources are exhausted.
+ *
+ * @param cls the `struct TransportClient`
+ * @param cqr failure message
+ */
+static void
+handle_queue_create_fail (
+  void *cls,
+  const struct GNUNET_TRANSPORT_CreateQueueResponse *cqr)
+{
+  struct TransportClient *tc = cls;
+
+  if (CT_COMMUNICATOR != tc->type)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (tc->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Request #%u for communicator to create queue failed\n",
+              (unsigned int) ntohs (cqr->request_id));
+  GNUNET_STATISTICS_update (GST_stats,
+                            "# Suggestions failed in queue creation at communicator",
+                            1,
+                            GNUNET_NO);
+  GNUNET_SERVICE_client_continue (tc->client);
+}
+
+
+/**
+ * We have received a `struct ExpressPreferenceMessage` from an application
+ * client.
+ *
+ * @param cls handle to the client
+ * @param msg the start message
+ */
+static void
+handle_suggest_cancel (void *cls, const struct ExpressPreferenceMessage *msg)
+{
+  struct TransportClient *tc = cls;
+  struct PeerRequest *pr;
+
+  if (CT_APPLICATION != tc->type)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (tc->client);
+    return;
+  }
+  pr = GNUNET_CONTAINER_multipeermap_get (tc->details.application.requests,
+                                          &msg->peer);
+  if (NULL == pr)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (tc->client);
+    return;
+  }
+  (void) stop_peer_request (tc, &pr->pid, pr);
+  GNUNET_SERVICE_client_continue (tc->client);
+}
+
+
+static void
+hello_for_client_cb (void *cls,
+                     const struct GNUNET_PeerIdentity *pid,
+                     const char *uri)
+{
+  (void) cls;
+  struct Queue *q;
+  int pfx_len;
+  const char *eou;
+  char *address;
+
+  eou = strstr (uri,
+                "://");
+  pfx_len = eou - uri;
+  eou += 3;
+  GNUNET_asprintf (&address,
+                   "%.*s-%s",
+                   pfx_len,
+                   uri,
+                   eou);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "hello for client %s\n",
+              address);
+
+  q = find_queue (pid, address);
+  if (NULL == q)
+  {
+    suggest_to_connect (pid, address);
+  }
+  else
+    start_address_validation (pid, address);
+  GNUNET_free (address);
+}
+
+
+/**
+ * Function called by PEERSTORE for each matching record.
+ *
+ * @param cls closure, a `struct PeerRequest`
+ * @param record peerstore record information
+ * @param emsg error message, or NULL if no errors
+ */
+static void
+handle_hello_for_client (void *cls,
+                         const struct GNUNET_PEERSTORE_Record *record,
+                         const char *emsg)
+{
+  struct PeerRequest *pr = cls;
+  struct GNUNET_HELLO_Builder *builder;
+  struct GNUNET_MessageHeader *hello;
+
+  if (NULL != emsg)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Got failure from PEERSTORE: %s\n",
+                emsg);
+    return;
+  }
+  hello = record->value;
+  if (0 == GNUNET_memcmp (&record->peer, &GST_my_identity))
+  {
+    GNUNET_PEERSTORE_monitor_next (pr->nc, 1);
+    return;
+  }
+  builder = GNUNET_HELLO_builder_from_msg (hello);
+  GNUNET_HELLO_builder_iterate (builder,
+                                hello_for_client_cb,
+                                NULL);
+  GNUNET_HELLO_builder_free (builder);
+}
+
+
+static void
+hello_for_client_error_cb (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Error in PEERSTORE monitoring\n");
+}
+
+
+static void
+hello_for_client_sync_cb (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Done with initial PEERSTORE iteration during monitoring\n");
+}
+
+
+/**
+ * We have received a `struct ExpressPreferenceMessage` from an application
+ * client.
+ *
+ * @param cls handle to the client
+ * @param msg the start message
+ */
+static void
+handle_suggest (void *cls, const struct ExpressPreferenceMessage *msg)
+{
+  struct TransportClient *tc = cls;
+  struct PeerRequest *pr;
+
+  if (CT_NONE == tc->type)
+  {
+    tc->type = CT_APPLICATION;
+    tc->details.application.requests =
+      GNUNET_CONTAINER_multipeermap_create (16, GNUNET_YES);
+  }
+  if (CT_APPLICATION != tc->type)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (tc->client);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Client suggested we talk to %s with preference %d at rate %u\n",
+              GNUNET_i2s (&msg->peer),
+              (int) ntohl (msg->pk),
+              (int) ntohl (msg->bw.value__));
+  pr = GNUNET_new (struct PeerRequest);
+  pr->tc = tc;
+  pr->pid = msg->peer;
+  pr->bw = msg->bw;
+  pr->pk = (enum GNUNET_MQ_PriorityPreferences) ntohl (msg->pk);
+  if (GNUNET_YES != GNUNET_CONTAINER_multipeermap_put (
+        tc->details.application.requests,
+        &pr->pid,
+        pr,
+        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+  {
+    GNUNET_break (0);
+    GNUNET_free (pr);
+    GNUNET_SERVICE_client_drop (tc->client);
+    return;
+  }
+  pr->nc =
+    GNUNET_PEERSTORE_monitor_start (GST_cfg,
+                                    GNUNET_YES,
+                                    "peerstore",
+                                    NULL,
+                                    GNUNET_PEERSTORE_HELLO_KEY,
+                                    &hello_for_client_error_cb,
+                                    NULL,
+                                    &hello_for_client_sync_cb,
+                                    NULL,
+                                    &handle_hello_for_client,
+                                    pr);
+  GNUNET_SERVICE_client_continue (tc->client);
+}
+
+
+/**
+ * Check #GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_HELLO_VALIDATION
+ * messages.
+ *
+ * @param cls a `struct TransportClient *`
+ * @param m message to verify
+ * @return #GNUNET_OK on success
+ */
+static int
+check_request_hello_validation (void *cls,
+                                const struct RequestHelloValidationMessage *m)
+{
+  (void) cls;
+  GNUNET_MQ_check_zero_termination (m);
+  return GNUNET_OK;
+}
+
+
+/**
+ * A client encountered an address of another peer. Consider validating it,
+ * and if validation succeeds, persist it to PEERSTORE.
+ *
+ * @param cls a `struct TransportClient *`
+ * @param m message to verify
+ */
+static void
+handle_request_hello_validation (void *cls,
+                                 const struct RequestHelloValidationMessage *m)
+{
+  struct TransportClient *tc = cls;
+  struct Queue *q;
+
+  q = find_queue (&m->peer, (const char *) &m[1]);
+  if (NULL == q)
+  {
+    suggest_to_connect (&m->peer, (const char *) &m[1]);
+  }
+  else
+    start_address_validation (&m->peer, (const char *) &m[1]);
+  GNUNET_SERVICE_client_continue (tc->client);
+}
+
+
+/**
+ * Free neighbour entry.
+ *
+ * @param cls NULL
+ * @param pid unused
+ * @param value a `struct Neighbour`
+ * @return #GNUNET_OK (always)
+ */
+static int
+free_neighbour_cb (void *cls,
+                   const struct GNUNET_PeerIdentity *pid,
+                   void *value)
+{
+  struct Neighbour *neighbour = value;
+
+  (void) cls;
+  (void) pid;
+  GNUNET_break (0);  // should this ever happen?
+  free_neighbour (neighbour);
+
+  return GNUNET_OK;
+}
+
+
+/**
+ * Free DV route entry.
+ *
+ * @param cls NULL
+ * @param pid unused
+ * @param value a `struct DistanceVector`
+ * @return #GNUNET_OK (always)
+ */
+static int
+free_dv_routes_cb (void *cls,
+                   const struct GNUNET_PeerIdentity *pid,
+                   void *value)
+{
+  struct DistanceVector *dv = value;
+
+  (void) cls;
+  (void) pid;
+  free_dv_route (dv);
+
+  return GNUNET_OK;
+}
+
+
+/**
+ * Free validation state.
+ *
+ * @param cls NULL
+ * @param pid unused
+ * @param value a `struct ValidationState`
+ * @return #GNUNET_OK (always)
+ */
+static int
+free_validation_state_cb (void *cls,
+                          const struct GNUNET_PeerIdentity *pid,
+                          void *value)
+{
+  struct ValidationState *vs = value;
+
+  (void) cls;
+  (void) pid;
+  free_validation_state (vs);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Free pending acknowledgement.
+ *
+ * @param cls NULL
+ * @param key unused
+ * @param value a `struct PendingAcknowledgement`
+ * @return #GNUNET_OK (always)
+ */
+static int
+free_pending_ack_cb (void *cls, const struct GNUNET_Uuid *key, void *value)
+{
+  struct PendingAcknowledgement *pa = value;
+
+  (void) cls;
+  (void) key;
+  free_pending_acknowledgement (pa);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Free acknowledgement cummulator.
+ *
+ * @param cls NULL
+ * @param pid unused
+ * @param value a `struct AcknowledgementCummulator`
+ * @return #GNUNET_OK (always)
+ */
+static int
+free_ack_cummulator_cb (void *cls,
+                        const struct GNUNET_PeerIdentity *pid,
+                        void *value)
+{
+  struct AcknowledgementCummulator *ac = value;
+
+  (void) cls;
+  (void) pid;
+  GNUNET_SCHEDULER_cancel (ac->task);
+  GNUNET_free (ac);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function called when the service shuts down.  Unloads our plugins
+ * and cancels pending validations.
+ *
+ * @param cls closure, unused
+ */
+static void
+do_shutdown (void *cls)
+{
+  struct LearnLaunchEntry *lle;
+  (void) cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "shutdown logic\n");
+  GNUNET_NAT_unregister (nh);
+  GNUNET_CONTAINER_multipeermap_iterate (neighbours,
+                                         &free_neighbour_cb, NULL);
+  if (NULL != validation_task)
+  {
+    GNUNET_SCHEDULER_cancel (validation_task);
+    validation_task = NULL;
+  }
+  if (NULL != dvlearn_task)
+  {
+    GNUNET_SCHEDULER_cancel (dvlearn_task);
+    dvlearn_task = NULL;
+  }
+  if (NULL != GST_stats)
+  {
+    GNUNET_STATISTICS_destroy (GST_stats, GNUNET_NO);
+    GST_stats = NULL;
+  }
+  if (NULL != GST_my_hello)
+  {
+    GNUNET_HELLO_builder_free (GST_my_hello);
+    GST_my_hello = NULL;
+  }
+  if (NULL != GST_my_private_key)
+  {
+    GNUNET_free (GST_my_private_key);
+    GST_my_private_key = NULL;
+  }
+  GNUNET_CONTAINER_multipeermap_iterate (ack_cummulators,
+                                         &free_ack_cummulator_cb,
+                                         NULL);
+  GNUNET_CONTAINER_multipeermap_destroy (ack_cummulators);
+  ack_cummulators = NULL;
+  GNUNET_CONTAINER_multiuuidmap_iterate (pending_acks,
+                                         &free_pending_ack_cb,
+                                         NULL);
+  GNUNET_CONTAINER_multiuuidmap_destroy (pending_acks);
+  pending_acks = NULL;
+  GNUNET_break (0 == GNUNET_CONTAINER_multipeermap_size (neighbours));
+  GNUNET_CONTAINER_multipeermap_destroy (neighbours);
+  neighbours = NULL;
+  GNUNET_break (0 == GNUNET_CONTAINER_multipeermap_size (links));
+  GNUNET_CONTAINER_multipeermap_destroy (links);
+  links = NULL;
+  GNUNET_CONTAINER_multipeermap_iterate (backtalkers,
+                                         &free_backtalker_cb,
+                                         NULL);
+  GNUNET_CONTAINER_multipeermap_destroy (backtalkers);
+  backtalkers = NULL;
+  GNUNET_CONTAINER_multipeermap_iterate (validation_map,
+                                         &free_validation_state_cb,
+                                         NULL);
+  GNUNET_CONTAINER_multipeermap_destroy (validation_map);
+  validation_map = NULL;
+  GNUNET_CONTAINER_multihashmap_destroy (revalidation_map);
+  revalidation_map = NULL;
+  while (NULL != ir_head)
+    free_incoming_request (ir_head);
+  GNUNET_assert (0 == ir_total);
+  while (NULL != (lle = lle_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (lle_head, lle_tail, lle);
+    GNUNET_free (lle);
+  }
+  if (NULL != peerstore)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Disconnecting from PEERSTORE service\n");
+    GNUNET_PEERSTORE_disconnect (peerstore);
+    peerstore = NULL;
+  }
+  GNUNET_CONTAINER_multishortmap_destroy (dvlearn_map);
+  dvlearn_map = NULL;
+  GNUNET_CONTAINER_heap_destroy (validation_heap);
+  validation_heap = NULL;
+  GNUNET_CONTAINER_multipeermap_iterate (dv_routes, &free_dv_routes_cb, NULL);
+  GNUNET_CONTAINER_multipeermap_destroy (dv_routes);
+  dv_routes = NULL;
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+static void
+shutdown_task (void *cls)
+{
+  in_shutdown = GNUNET_YES;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Shutdown task executed\n");
+  if (NULL != clients_head)
+  {
+    for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "client still connected: %u\n",
+                  tc->type);
+    }
+  }
+  else
+    do_shutdown (cls);
+
+}
+
+
+/**
+ * Initiate transport 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)
+{
+  (void) cls;
+  (void) service;
+  /* setup globals */
+  hello_mono_time = GNUNET_TIME_absolute_get_monotonic (c);
+  in_shutdown = GNUNET_NO;
+  GST_cfg = c;
+  backtalkers = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_YES);
+  pending_acks = GNUNET_CONTAINER_multiuuidmap_create (32768, GNUNET_YES);
+  ack_cummulators = GNUNET_CONTAINER_multipeermap_create (256, GNUNET_YES);
+  neighbours = GNUNET_CONTAINER_multipeermap_create (1024, GNUNET_YES);
+  links = GNUNET_CONTAINER_multipeermap_create (512, GNUNET_YES);
+  dv_routes = GNUNET_CONTAINER_multipeermap_create (1024, GNUNET_YES);
+  dvlearn_map = GNUNET_CONTAINER_multishortmap_create (2 * MAX_DV_LEARN_PENDING,
+                                                       GNUNET_YES);
+  validation_map = GNUNET_CONTAINER_multipeermap_create (1024, GNUNET_YES);
+  revalidation_map = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_YES);
+  validation_heap =
+    GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+  GST_my_private_key =
+    GNUNET_CRYPTO_eddsa_key_create_from_configuration (GST_cfg);
+  if (NULL == GST_my_private_key)
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_ERROR,
+      _ (
+        "Transport service is lacking key configuration settings. Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_CRYPTO_eddsa_key_get_public (GST_my_private_key,
+                                      &GST_my_identity.public_key);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "My identity is `%s'\n",
+              GNUNET_i2s_full (&GST_my_identity));
+  GST_my_hello = GNUNET_HELLO_builder_new (&GST_my_identity);
+  GST_stats = GNUNET_STATISTICS_create ("transport", GST_cfg);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
+  peerstore = GNUNET_PEERSTORE_connect (GST_cfg);
+  nh = GNUNET_NAT_register (GST_cfg,
+                            "transport",
+                            0,
+                            0,
+                            NULL,
+                            0,
+                            NULL,
+                            NULL,
+                            NULL);
+  if (NULL == peerstore)
+  {
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+}
+
+
+/**
+ * Define "main" method using service macro.
+ */
+GNUNET_SERVICE_MAIN (
+  "transport",
+  GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN,
+  &run,
+  &client_connect_cb,
+  &client_disconnect_cb,
+  NULL,
+  /* communication with applications */
+  GNUNET_MQ_hd_fixed_size (suggest,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST,
+                           struct ExpressPreferenceMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (suggest_cancel,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST_CANCEL,
+                           struct ExpressPreferenceMessage,
+                           NULL),
+  GNUNET_MQ_hd_var_size (request_hello_validation,
+                         GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_HELLO_VALIDATION,
+                         struct RequestHelloValidationMessage,
+                         NULL),
+  /* communication with core */
+  GNUNET_MQ_hd_fixed_size (client_start,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_START,
+                           struct StartMessage,
+                           NULL),
+  GNUNET_MQ_hd_var_size (client_send,
+                         GNUNET_MESSAGE_TYPE_TRANSPORT_SEND,
+                         struct OutboundMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (client_recv_ok,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_RECV_OK,
+                           struct RecvOkMessage,
+                           NULL),
+  /* communication with communicators */
+  GNUNET_MQ_hd_var_size (communicator_available,
+                         GNUNET_MESSAGE_TYPE_TRANSPORT_NEW_COMMUNICATOR,
+                         struct GNUNET_TRANSPORT_CommunicatorAvailableMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (communicator_backchannel,
+                         GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL,
+                         struct GNUNET_TRANSPORT_CommunicatorBackchannel,
+                         NULL),
+  GNUNET_MQ_hd_var_size (add_address,
+                         GNUNET_MESSAGE_TYPE_TRANSPORT_ADD_ADDRESS,
+                         struct GNUNET_TRANSPORT_AddAddressMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (del_address,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_DEL_ADDRESS,
+                           struct GNUNET_TRANSPORT_DelAddressMessage,
+                           NULL),
+  GNUNET_MQ_hd_var_size (incoming_msg,
+                         GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG,
+                         struct GNUNET_TRANSPORT_IncomingMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (queue_create_ok,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_OK,
+                           struct GNUNET_TRANSPORT_CreateQueueResponse,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (queue_create_fail,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_FAIL,
+                           struct GNUNET_TRANSPORT_CreateQueueResponse,
+                           NULL),
+  GNUNET_MQ_hd_var_size (add_queue_message,
+                         GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP,
+                         struct GNUNET_TRANSPORT_AddQueueMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (update_queue_message,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_UPDATE,
+                           struct GNUNET_TRANSPORT_UpdateQueueMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (del_queue_message,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_TEARDOWN,
+                           struct GNUNET_TRANSPORT_DelQueueMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (send_message_ack,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG_ACK,
+                           struct GNUNET_TRANSPORT_SendMessageToAck,
+                           NULL),
+  /* communication with monitors */
+  GNUNET_MQ_hd_fixed_size (monitor_start,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_START,
+                           struct GNUNET_TRANSPORT_MonitorStart,
+                           NULL),
+  GNUNET_MQ_handler_end ());
+
+
+/* end of file gnunet-service-transport.c */
diff --git a/src/service/transport/gnunet-service-transport.h b/src/service/transport/gnunet-service-transport.h
new file mode 100644
index 000000000..ea9e71e4b
--- /dev/null
+++ b/src/service/transport/gnunet-service-transport.h
@@ -0,0 +1,234 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2010,2011 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file transport/gnunet-service-transport.h
+ * @brief globals
+ * @author Christian Grothoff
+ */
+#ifndef GNUNET_SERVICE_TRANSPORT_H
+#define GNUNET_SERVICE_TRANSPORT_H
+
+#include "gnunet_util_lib.h"
+#include "gnunet_statistics_service.h"
+#include "gnunet_ats_service.h"
+#include "gnunet_transport_service.h"
+
+#define VERBOSE_VALIDATION GNUNET_YES
+
+/**
+ * Statistics handle.
+ */
+extern struct GNUNET_STATISTICS_Handle *GST_stats;
+
+/**
+ * Configuration handle.
+ */
+extern const struct GNUNET_CONFIGURATION_Handle *GST_cfg;
+
+/**
+ * Configuration handle.
+ */
+extern struct GNUNET_PeerIdentity GST_my_identity;
+
+/**
+ * Handle to peerinfo service.
+ */
+extern struct GNUNET_PEERINFO_Handle *GST_peerinfo;
+
+/**
+ * Our private key.
+ */
+extern struct GNUNET_CRYPTO_EddsaPrivateKey GST_my_private_key;
+
+/**
+ * ATS handle.
+ */
+extern struct GNUNET_ATS_SchedulingHandle *GST_ats;
+
+/**
+ * ATS connectivity handle.
+ */
+extern struct GNUNET_ATS_ConnectivityHandle *GST_ats_connect;
+
+/**
+ * Interface scanner determines our LAN address range(s).
+ */
+extern struct GNUNET_NT_InterfaceScanner *GST_is;
+
+
+/**
+ * Function to call when a peer's address has changed
+ *
+ * @param cls closure
+ * @param peer peer this update is about,
+ * @param address address, NULL for disconnect notification
+ */
+typedef void
+(*GNUNET_TRANSPORT_NeighbourChangeCallback) (void *cls,
+                                             const struct
+                                             GNUNET_PeerIdentity *peer,
+                                             const struct
+                                             GNUNET_HELLO_Address *address,
+                                             enum GNUNET_TRANSPORT_PeerState
+                                             state,
+                                             struct GNUNET_TIME_Absolute
+                                             state_timeout,
+                                             struct GNUNET_BANDWIDTH_Value32NBO
+                                             bandwidth_in,
+                                             struct GNUNET_BANDWIDTH_Value32NBO
+                                             bandwidth_out);
+
+
+/**
+ * Continuation called from a blacklist test.
+ *
+ * @param cls closure
+ * @param peer identity of peer that was tested
+ * @param address address associated with the request
+ * @param session session associated with the request
+ * @param result #GNUNET_OK if the connection is allowed,
+ *               #GNUNET_NO if not,
+ *               #GNUNET_SYSERR if operation was aborted
+ */
+typedef void
+(*GST_BlacklistTestContinuation) (void *cls,
+                                  const struct GNUNET_PeerIdentity *peer,
+                                  const struct GNUNET_HELLO_Address *address,
+                                  struct GNUNET_ATS_Session *session,
+                                  int result);
+
+
+/**
+ * Add the given peer to the blacklist (for the given transport).
+ *
+ * @param peer peer to blacklist
+ * @param transport_name transport to blacklist for this peer, NULL for all
+ */
+void
+GST_blacklist_add_peer (const struct GNUNET_PeerIdentity *peer,
+                        const char *transport_name);
+
+
+/**
+ * Handle to an active blacklist check.
+ */
+struct GST_BlacklistCheck;
+
+
+/**
+ * Test if a peer/transport combination is blacklisted.
+ *
+ * @param peer the identity of the peer to test
+ * @param transport_name name of the transport to test, never NULL
+ * @param cont function to call with result
+ * @param cont_cls closure for @a cont
+ * @param address address to pass back to @a cont, can be NULL
+ * @param session session to pass back to @a cont, can be NULL
+ * @return handle to the blacklist check, NULL if the decision
+ *        was made instantly and @a cont was already called
+ */
+struct GST_BlacklistCheck *
+GST_blacklist_test_allowed (const struct GNUNET_PeerIdentity *peer,
+                            const char *transport_name,
+                            GST_BlacklistTestContinuation cont,
+                            void *cont_cls,
+                            const struct GNUNET_HELLO_Address *address,
+                            struct GNUNET_ATS_Session *session);
+
+
+/**
+ * Abort blacklist if @a address and @a session match.
+ *
+ * @param address address used to abort matching checks
+ * @param session session used to abort matching checks
+ */
+void
+GST_blacklist_abort_matching (const struct GNUNET_HELLO_Address *address,
+                              struct GNUNET_ATS_Session *session);
+
+/**
+ * Cancel a blacklist check.
+ *
+ * @param bc check to cancel
+ */
+void
+GST_blacklist_test_cancel (struct GST_BlacklistCheck *bc);
+
+
+/**
+ * Function called by the transport for each received message.
+ *
+ * @param cls closure, const char* with the name of the plugin we received the message from
+ * @param address address and (claimed) identity of the other peer
+ * @param session identifier used for this session (NULL for plugins
+ *                that do not offer bi-directional communication to the sender
+ *                using the same "connection")
+ * @param message the message, NULL if we only care about
+ *                learning about the delay until we should receive again
+ * @return how long the plugin should wait until receiving more data
+ *         (plugins that do not support this, can ignore the return value)
+ */
+struct GNUNET_TIME_Relative
+GST_receive_callback (void *cls,
+                      const struct GNUNET_HELLO_Address *address,
+                      struct GNUNET_ATS_Session *session,
+                      const struct GNUNET_MessageHeader *message);
+
+/**
+ * Broadcast the given message to all of our clients.
+ *
+ * @param msg message to broadcast
+ * @param may_drop #GNUNET_YES if the message can be dropped / is payload
+ */
+void
+GST_clients_broadcast (const struct GNUNET_MessageHeader *msg,
+                       int may_drop);
+
+
+/**
+ * Broadcast the new active address to all clients monitoring the peer.
+ *
+ * @param peer peer this update is about (never NULL)
+ * @param address address, NULL on disconnect
+ * @param state the current state of the peer
+ * @param state_timeout the time out for the state
+ */
+void
+GST_clients_broadcast_peer_notification (const struct GNUNET_PeerIdentity *peer,
+                                         const struct
+                                         GNUNET_HELLO_Address *address,
+                                         enum GNUNET_TRANSPORT_PeerState state,
+                                         struct GNUNET_TIME_Absolute
+                                         state_timeout);
+
+
+/**
+ * Notify all clients about a disconnect, and cancel
+ * pending SEND_OK messages for this peer.
+ *
+ * @param peer peer that disconnected
+ */
+void
+GST_clients_broadcast_disconnect (const struct GNUNET_PeerIdentity *peer);
+
+
+#endif
+/* end of file gnunet-service-transport_plugins.h */
diff --git a/src/service/transport/gnunet-transport-certificate-creation.in b/src/service/transport/gnunet-transport-certificate-creation.in
new file mode 100644
index 000000000..771422a7a
--- /dev/null
+++ b/src/service/transport/gnunet-transport-certificate-creation.in
@@ -0,0 +1,158 @@
+#!/bin/sh
+#
+# This shell script will generate an X509 certificate for
+# your gnunet-transport HTTPS
+#
+# The current version partially reuses and recycles
+# code from build.sh by NetBSD (although not entirely
+# used because it needs debugging):
+#
+# Copyright (c) 2001-2011 The NetBSD Foundation, Inc.
+# All rights reserved.
+#
+# This code is derived from software contributed to
+# The NetBSD Foundation by Todd Vierling and Luke Mewburn.
+
+# Redistribution and use in source and binary forms, with or
+# without modification, are permitted provided that the following
+# conditions are met:
+# 1. Redistributions of source code must retain the above
+#    copyright notice, this list of conditions and the following
+#    disclaimer.
+# 2. Redistributions in binary form must reproduce the above
+#    copyright notice, this list of conditions and the following
+#    disclaimer in the documentation and/or other materials
+#    provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
+# CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED.
+# IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+# OF SUCH DAMAGE.
+
+progname=${0##*/}
+
+existence() {
+  command -v "$1" >/dev/null 2>&1
+}
+
+setdefaults()
+{
+    verbosity=0
+    runcmd=
+}
+
+statusmsg()
+{
+    ${runcmd} echo "    $@"
+}
+
+infomsg()
+{
+    if [ x$verbosity = x1 ]; then
+        statusmsg "INFO: $@"
+    fi
+}
+
+warningmsg()
+{
+    statusmsg "WARNING: $@"
+}
+
+errormsg()
+{
+    statusmsg "ERROR: $@"
+}
+
+linemsg()
+{
+    statusmsg "========================================="
+}
+
+
+usage()
+{
+    if [ -n "$*" ]; then
+        echo ""
+        echo "${progname}: $*"
+    fi
+    cat <<_usage_
+
+Usage: ${progname} [-hv] [-c FILE] [...]
+
+Options:
+   -c FILE      Use the configuration file FILE.
+   -h           Print this help message.
+   -v           Print the version and exit.
+   -V           be verbose
+
+_usage_
+        exit 1
+}
+
+
+generate_cert_key()
+{
+    echo ""
+    infomsg "Generating Cert and Key"
+
+    CERTTOOL=""
+    GNUTLS_CA_TEMPLATE=@PKGDATADIRECTORY@/gnunet-gns-proxy-ca.template
+    OPENSSL=0
+    if test -x $(existence gnutls-certtool)
+    #if test -z "`gnutls-certtool --version`" > /dev/null
+    then
+      if test -z "`certtool --version | grep gnutls`" > /dev/null
+      then
+        warningmsg "'gnutls-certtool' or 'certtool' command not found. Trying openssl."
+        # if test -z "`openssl version`" > /dev/null
+        if test -x $(existence openssl)
+        then
+          OPENSSL=1
+        else
+          warningmsg "Install either gnutls certtool or openssl for certificate generation!"
+          statusmsg  "Cleaning up."
+          exit 1
+        fi
+      fi
+      CERTTOOL="certtool"
+    else
+      CERTTOOL="gnutls-certtool"
+    fi
+    mkdir -p `dirname $KEYFILE`
+
+    if test 1 -eq $OPENSSL
+    then
+      openssl genrsa -out $KEYFILE 1024
+      openssl req -batch -days 365 -out $CERTFILE -new -x509 -key $KEYFILE
+    else
+      $CERTTOOL --generate-privkey --outfile $KEYFILE 2>/dev/null
+      $CERTTOOL --template $GNUTLS_CA_TEMPLATE --generate-self-signed --load-privkey $KEYFILE --outfile $CERTFILE 2>/dev/null
+    fi
+  }
+
+print_version()
+{
+  GNUNET_ARM_VERSION=`gnunet-arm -v`
+  echo $GNUNET_ARM_VERSION
+}
+
+main()
+{
+  KEYFILE=$1
+  CERTFILE=$2
+  setdefaults
+  generate_cert_key
+}
+
+main "$@"
diff --git a/src/service/transport/gnunet-transport.c b/src/service/transport/gnunet-transport.c
new file mode 100644
index 000000000..b5ad43770
--- /dev/null
+++ b/src/service/transport/gnunet-transport.c
@@ -0,0 +1,1437 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2011-2014, 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 src/transport/gnunet-transport.c
+ * @brief Tool to help configure, measure and control the transport subsystem.
+ * @author Christian Grothoff
+ * @author Nathan Evans
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_resolver_service.h"
+#include "gnunet_protocols.h"
+#include "gnunet_transport_service.h"
+
+/**
+ * Timeout for a name resolution
+ */
+#define RESOLUTION_TIMEOUT \
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
+
+/**
+ * Timeout for an operation
+ */
+#define OP_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
+
+
+/**
+ * Context to store name resolutions for valiation
+ */
+struct ValidationResolutionContext
+{
+  /**
+   * Next in DLL
+   */
+  struct ValidationResolutionContext *next;
+
+  /**
+   * Previous in DLL
+   */
+  struct ValidationResolutionContext *prev;
+
+  /**
+   * Address to resolve
+   */
+  struct GNUNET_HELLO_Address *addrcp;
+
+  /**
+   * Time of last validation
+   */
+  struct GNUNET_TIME_Absolute last_validation;
+
+  /**
+   * Address is valid until
+   */
+  struct GNUNET_TIME_Absolute valid_until;
+
+  /**
+   * Time of next validation
+   */
+  struct GNUNET_TIME_Absolute next_validation;
+
+  /**
+   * Transport conversion handle
+   */
+  struct GNUNET_TRANSPORT_AddressToStringContext *asc;
+
+  /**
+   * plugin name
+   */
+  char *transport;
+
+  /**
+   * was the entry printed
+   */
+  int printed;
+};
+
+/**
+ * Struct to store information about peers in monitor mode
+ */
+struct MonitoredPeer
+{
+  /**
+   * State of the peer
+   */
+  enum GNUNET_TRANSPORT_PeerState state;
+
+  /**
+   * Timeout
+   */
+  struct GNUNET_TIME_Absolute state_timeout;
+
+  /**
+   * The address to convert
+   */
+  struct GNUNET_HELLO_Address *address;
+};
+
+/**
+ * Context to store name resolutions for valiation
+ */
+struct PeerResolutionContext
+{
+  /**
+   * Next in DLL
+   */
+  struct PeerResolutionContext *next;
+
+  /**
+   * Prev in DLL
+   */
+  struct PeerResolutionContext *prev;
+
+  /**
+   * address to resolve
+   */
+  struct GNUNET_HELLO_Address *addrcp;
+
+  /**
+   * transport conversiion context
+   */
+  struct GNUNET_TRANSPORT_AddressToStringContext *asc;
+
+  /**
+   * peer state
+   */
+  enum GNUNET_TRANSPORT_PeerState state;
+
+  /**
+   * state timeout
+   */
+  struct GNUNET_TIME_Absolute state_timeout;
+
+  /**
+   * transport plugin
+   */
+  char *transport;
+
+  /**
+   * was the entry printed
+   */
+  int printed;
+};
+
+
+/**
+ * Benchmarking block size in KB
+ */
+#define BLOCKSIZE 4
+
+/**
+ * Handle to transport service.
+ */
+static struct GNUNET_TRANSPORT_CoreHandle *handle;
+
+/**
+ * Configuration handle
+ */
+static struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Blacklisting handle
+ */
+struct GNUNET_TRANSPORT_Blacklist *blacklist;
+
+/**
+ * Option -s.
+ */
+static int benchmark_send;
+
+/**
+ * Option -b.
+ */
+static int benchmark_receive;
+
+/**
+ * Option -l.
+ */
+static int benchmark_receive;
+
+/**
+ * Option -i.
+ */
+static int iterate_connections;
+
+/**
+ * Option -a.
+ */
+static int iterate_all;
+
+/**
+ * Option -c.
+ */
+static int monitor_connects;
+
+/**
+ * Option -m.
+ */
+static int monitor_connections;
+
+/**
+ * Option -P.
+ */
+static int monitor_plugins;
+
+/**
+ * Option -D.
+ */
+static int do_disconnect;
+
+/**
+ * Option -n.
+ */
+static int numeric;
+
+/**
+ * Global return value (0 success).
+ */
+static int ret;
+
+/**
+ * Current number of connections in monitor mode
+ */
+static int monitor_connect_counter;
+
+/**
+ * Number of bytes of traffic we received so far.
+ */
+static unsigned long long traffic_received;
+
+/**
+ * Number of bytes of traffic we sent so far.
+ */
+static unsigned long long traffic_sent;
+
+/**
+ * Starting time of transmitting/receiving data.
+ */
+static struct GNUNET_TIME_Absolute start_time;
+
+/**
+ * Map storing information about monitored peers
+ */
+static struct GNUNET_CONTAINER_MultiPeerMap *monitored_peers;
+
+/**
+ * Map storing information about monitored plugins's sessions.
+ */
+static struct GNUNET_CONTAINER_MultiPeerMap *monitored_plugins;
+
+/**
+ * Handle if we are monitoring peers at the transport level.
+ */
+static struct GNUNET_TRANSPORT_PeerMonitoringContext *pic;
+
+/**
+ * Handle if we are monitoring plugin session activity.
+ */
+static struct GNUNET_TRANSPORT_PluginMonitor *pm;
+
+/**
+ * Identity of the peer we transmit to / connect to.
+ * ('-p' command-line option).
+ */
+static struct GNUNET_PeerIdentity pid;
+
+/**
+ * Task for operation timeout
+ */
+static struct GNUNET_SCHEDULER_Task *op_timeout;
+
+/**
+ * Selected level of verbosity.
+ */
+static unsigned int verbosity;
+
+/**
+ * Resolver process handle.
+ */
+struct GNUNET_OS_Process *resolver;
+
+/**
+ * Number of address resolutions pending
+ */
+static unsigned int address_resolutions;
+
+/**
+ * DLL: head of validation resolution entries
+ */
+static struct ValidationResolutionContext *vc_head;
+
+/**
+ * DLL: tail of validation resolution entries
+ */
+static struct ValidationResolutionContext *vc_tail;
+
+/**
+ * DLL: head of resolution entries
+ */
+static struct PeerResolutionContext *rc_head;
+
+/**
+ * DLL: head of resolution entries
+ */
+static struct PeerResolutionContext *rc_tail;
+
+
+/**
+ * Function called to release data stored in the #monitored_peers map.
+ *
+ * @param cls unused
+ * @param key the peer identity
+ * @param value a `struct MonitoredPeer` to release
+ * @return #GNUNET_OK (continue to iterate)
+ */
+static int
+destroy_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
+{
+  struct MonitoredPeer *m = value;
+
+  GNUNET_assert (
+    GNUNET_OK ==
+    GNUNET_CONTAINER_multipeermap_remove (monitored_peers, key, value));
+  GNUNET_free (m->address);
+  GNUNET_free (value);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Task run in monitor mode when the user presses CTRL-C to abort.
+ * Stops monitoring activity.
+ *
+ * @param cls NULL
+ */
+static void
+shutdown_task (void *cls)
+{
+  struct GNUNET_TIME_Relative duration;
+  struct ValidationResolutionContext *cur;
+  struct ValidationResolutionContext *next;
+  struct PeerResolutionContext *rc;
+
+  if (NULL != op_timeout)
+  {
+    GNUNET_SCHEDULER_cancel (op_timeout);
+    op_timeout = NULL;
+  }
+  if (NULL != pic)
+  {
+    GNUNET_TRANSPORT_monitor_peers_cancel (pic);
+    pic = NULL;
+  }
+  if (NULL != pm)
+  {
+    GNUNET_TRANSPORT_monitor_plugins_cancel (pm);
+    pm = NULL;
+  }
+
+  next = vc_head;
+  for (cur = next; NULL != cur; cur = next)
+  {
+    next = cur->next;
+
+    GNUNET_TRANSPORT_address_to_string_cancel (cur->asc);
+    GNUNET_CONTAINER_DLL_remove (vc_head, vc_tail, cur);
+    GNUNET_free (cur->transport);
+    GNUNET_HELLO_address_free (cur->addrcp);
+    GNUNET_free (cur);
+  }
+  while (NULL != (rc = rc_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (rc_head, rc_tail, rc);
+    GNUNET_TRANSPORT_address_to_string_cancel (rc->asc);
+    GNUNET_free (rc->transport);
+    GNUNET_free (rc->addrcp);
+    GNUNET_free (rc);
+  }
+  if (NULL != handle)
+  {
+    GNUNET_TRANSPORT_core_disconnect (handle);
+    handle = NULL;
+  }
+  if (benchmark_send)
+  {
+    duration = GNUNET_TIME_absolute_get_duration (start_time);
+    fprintf (stdout,
+             _ ("Transmitted %llu bytes/s (%llu bytes in %s)\n"),
+             1000LL * 1000LL * traffic_sent / (1 + duration.rel_value_us),
+             traffic_sent,
+             GNUNET_STRINGS_relative_time_to_string (duration, GNUNET_YES));
+  }
+  if (benchmark_receive)
+  {
+    duration = GNUNET_TIME_absolute_get_duration (start_time);
+    fprintf (stdout,
+             _ ("Received %llu bytes/s (%llu bytes in %s)\n"),
+             1000LL * 1000LL * traffic_received / (1 + duration.rel_value_us),
+             traffic_received,
+             GNUNET_STRINGS_relative_time_to_string (duration, GNUNET_YES));
+  }
+
+  if (NULL != monitored_peers)
+  {
+    GNUNET_CONTAINER_multipeermap_iterate (monitored_peers, &destroy_it, NULL);
+    GNUNET_CONTAINER_multipeermap_destroy (monitored_peers);
+    monitored_peers = NULL;
+  }
+  if (NULL != monitored_plugins)
+  {
+    GNUNET_break (0 == GNUNET_CONTAINER_multipeermap_size (monitored_plugins));
+    GNUNET_CONTAINER_multipeermap_destroy (monitored_plugins);
+    monitored_plugins = NULL;
+  }
+  if (NULL != blacklist)
+  {
+    GNUNET_TRANSPORT_blacklist_cancel (blacklist);
+    blacklist = NULL;
+    ret = 0;
+  }
+}
+
+
+/**
+ * We are done, shut down.
+ */
+static void
+operation_timeout (void *cls)
+{
+  struct PeerResolutionContext *cur;
+  struct PeerResolutionContext *next;
+
+  op_timeout = NULL;
+  if ((benchmark_send) || (benchmark_receive))
+  {
+    fprintf (stdout, _ ("Failed to connect to `%s'\n"), GNUNET_i2s_full (&pid));
+    GNUNET_SCHEDULER_shutdown ();
+    ret = 1;
+    return;
+  }
+  if (iterate_connections)
+  {
+    next = rc_head;
+    while (NULL != (cur = next))
+    {
+      next = cur->next;
+      fprintf (stdout,
+               _ ("Failed to resolve address for peer `%s'\n"),
+               GNUNET_i2s (&cur->addrcp->peer));
+
+      GNUNET_CONTAINER_DLL_remove (rc_head, rc_tail, cur);
+      GNUNET_TRANSPORT_address_to_string_cancel (cur->asc);
+      GNUNET_free (cur->transport);
+      GNUNET_free (cur->addrcp);
+      GNUNET_free (cur);
+    }
+    fprintf (stdout,
+             "%s",
+             _ ("Failed to list connections, timeout occurred\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    ret = 1;
+    return;
+  }
+}
+
+
+/**
+ * Function called to notify a client about the socket
+ * begin ready to queue more data.  Sends another message.
+ *
+ * @param cls closure with the message queue
+ */
+static void
+do_send (void *cls)
+{
+  struct GNUNET_MQ_Handle *mq = cls;
+  struct GNUNET_MessageHeader *m;
+  struct GNUNET_MQ_Envelope *env;
+
+  env = GNUNET_MQ_msg_extra (m, BLOCKSIZE * 1024, GNUNET_MESSAGE_TYPE_DUMMY);
+  memset (&m[1], 52, BLOCKSIZE * 1024 - sizeof(struct GNUNET_MessageHeader));
+  traffic_sent += BLOCKSIZE * 1024;
+  GNUNET_MQ_notify_sent (env, &do_send, mq);
+  if (verbosity > 0)
+    fprintf (stdout,
+             _ ("Transmitting %u bytes\n"),
+             (unsigned int) BLOCKSIZE * 1024);
+  GNUNET_MQ_send (mq, env);
+}
+
+
+/**
+ * Function called to notify transport users that another
+ * peer connected to us.
+ *
+ * @param cls closure
+ * @param peer the peer that connected
+ * @param mq message queue for sending to @a peer
+ */
+static void *
+notify_connect (void *cls,
+                const struct GNUNET_PeerIdentity *peer,
+                struct GNUNET_MQ_Handle *mq)
+{
+  if (0 != memcmp (&pid, peer, sizeof(struct GNUNET_PeerIdentity)))
+    return NULL;
+  ret = 0;
+  if (! benchmark_send)
+    return NULL;
+  if (NULL != op_timeout)
+  {
+    GNUNET_SCHEDULER_cancel (op_timeout);
+    op_timeout = NULL;
+  }
+  if (verbosity > 0)
+    fprintf (
+      stdout,
+      _ (
+        "Successfully connected to `%s', starting to send benchmark data in %u Kb blocks\n"),
+      GNUNET_i2s (peer),
+      BLOCKSIZE);
+  start_time = GNUNET_TIME_absolute_get ();
+  do_send (mq);
+  return mq;
+}
+
+
+/**
+ * Function called to notify transport users that another
+ * peer disconnected from us.
+ *
+ * @param cls closure
+ * @param peer the peer that disconnected
+ * @param internal_cls what we returned from #notify_connect()
+ */
+static void
+notify_disconnect (void *cls,
+                   const struct GNUNET_PeerIdentity *peer,
+                   void *internal_cls)
+{
+  if (0 != memcmp (&pid, peer, sizeof(struct GNUNET_PeerIdentity)))
+    return;
+  if (NULL == internal_cls)
+    return; /* not about target peer */
+  if (! benchmark_send)
+    return; /* not transmitting */
+  fprintf (stdout,
+           _ ("Disconnected from peer `%s' while benchmarking\n"),
+           GNUNET_i2s (&pid));
+}
+
+
+/**
+ * Function called to notify transport users that another
+ * peer connected to us.
+ *
+ * @param cls closure
+ * @param peer the peer that connected
+ * @param mq for sending messages to @a peer
+ * @return NULL
+ */
+static void *
+monitor_notify_connect (void *cls,
+                        const struct GNUNET_PeerIdentity *peer,
+                        struct GNUNET_MQ_Handle *mq)
+{
+  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
+  const char *now_str = GNUNET_STRINGS_absolute_time_to_string (now);
+
+  monitor_connect_counter++;
+  fprintf (stdout,
+           _ ("%24s: %-17s %4s   (%u connections in total)\n"),
+           now_str,
+           _ ("Connected to"),
+           GNUNET_i2s (peer),
+           monitor_connect_counter);
+  return NULL;
+}
+
+
+/**
+ * Function called to notify transport users that another
+ * peer disconnected from us.
+ *
+ * @param cls closure
+ * @param peer the peer that disconnected
+ * @param internal_cls what we returned from #monitor_notify_connect()
+ */
+static void
+monitor_notify_disconnect (void *cls,
+                           const struct GNUNET_PeerIdentity *peer,
+                           void *internal_cls)
+{
+  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
+  const char *now_str = GNUNET_STRINGS_absolute_time_to_string (now);
+
+  GNUNET_assert (monitor_connect_counter > 0);
+  monitor_connect_counter--;
+
+  fprintf (stdout,
+           _ ("%24s: %-17s %4s   (%u connections in total)\n"),
+           now_str,
+           _ ("Disconnected from"),
+           GNUNET_i2s (peer),
+           monitor_connect_counter);
+}
+
+
+/**
+ * Function called by the transport for each received message.
+ *
+ * @param cls closure
+ * @param message the message
+ * @return #GNUNET_OK
+ */
+static int
+check_dummy (void *cls, const struct GNUNET_MessageHeader *message)
+{
+  return GNUNET_OK; /* all messages are fine */
+}
+
+
+/**
+ * Function called by the transport for each received message.
+ *
+ * @param cls closure
+ * @param message the message
+ */
+static void
+handle_dummy (void *cls, const struct GNUNET_MessageHeader *message)
+{
+  if (! benchmark_receive)
+    return;
+  if (verbosity > 0)
+    fprintf (stdout,
+             _ ("Received %u bytes\n"),
+             (unsigned int) ntohs (message->size));
+  if (0 == traffic_received)
+    start_time = GNUNET_TIME_absolute_get ();
+  traffic_received += ntohs (message->size);
+}
+
+
+/**
+ * Convert address to a printable format.
+ *
+ * @param address the address
+ * @param numeric #GNUNET_YES to convert to numeric format, #GNUNET_NO
+ *                to try to use reverse DNS
+ * @param state state the peer is in
+ * @param state_timeout when will the peer's state expire
+ */
+static void
+resolve_peer_address (const struct GNUNET_HELLO_Address *address,
+                      int numeric,
+                      enum GNUNET_TRANSPORT_PeerState state,
+                      struct GNUNET_TIME_Absolute state_timeout);
+
+
+static void
+print_info (const struct GNUNET_PeerIdentity *id,
+            const char *transport,
+            const char *addr,
+            enum GNUNET_TRANSPORT_PeerState state,
+            struct GNUNET_TIME_Absolute state_timeout)
+{
+  if (((GNUNET_YES == iterate_connections) && (GNUNET_YES == iterate_all)) ||
+      (GNUNET_YES == monitor_connections))
+  {
+    fprintf (stdout,
+             _ ("Peer `%s': %s %s in state `%s' until %s\n"),
+             GNUNET_i2s (id),
+             (NULL == transport) ? "<none>" : transport,
+             (NULL == transport) ? "<none>" : addr,
+             GNUNET_TRANSPORT_ps2s (state),
+             GNUNET_STRINGS_absolute_time_to_string (state_timeout));
+  }
+  else if ((GNUNET_YES == iterate_connections) &&
+           (GNUNET_TRANSPORT_is_connected (state)))
+  {
+    /* Only connected peers, skip state */
+    fprintf (stdout,
+             _ ("Peer `%s': %s %s\n"),
+             GNUNET_i2s (id),
+             transport,
+             addr);
+  }
+}
+
+
+/**
+ * Function called with a textual representation of an address.  This
+ * function will be called several times with different possible
+ * textual representations, and a last time with @a address being NULL
+ * to signal the end of the iteration.  Note that @a address NULL
+ * always is the last call, regardless of the value in @a res.
+ *
+ * @param cls closure
+ * @param address NULL on end of iteration,
+ *        otherwise 0-terminated printable UTF-8 string,
+ *        in particular an empty string if @a res is #GNUNET_NO
+ * @param res result of the address to string conversion:
+ *        if #GNUNET_OK: conversion successful
+ *        if #GNUNET_NO: address was invalid (or not supported)
+ *        if #GNUNET_SYSERR: communication error (IPC error)
+ */
+static void
+process_peer_string (void *cls, const char *address, int res)
+{
+  struct PeerResolutionContext *rc = cls;
+
+  if (NULL != address)
+  {
+    if (GNUNET_SYSERR == res)
+    {
+      fprintf (
+        stderr,
+        "Failed to convert address for peer `%s' plugin `%s' length %u to string \n",
+        GNUNET_i2s (&rc->addrcp->peer),
+        rc->addrcp->transport_name,
+        (unsigned int) rc->addrcp->address_length);
+      print_info (&rc->addrcp->peer,
+                  rc->transport,
+                  NULL,
+                  rc->state,
+                  rc->state_timeout);
+      rc->printed = GNUNET_YES;
+      return;
+    }
+    if (GNUNET_OK == res)
+    {
+      print_info (&rc->addrcp->peer,
+                  rc->transport,
+                  address,
+                  rc->state,
+                  rc->state_timeout);
+      rc->printed = GNUNET_YES;
+      return;     /* Wait for done call */
+    }
+    /* GNUNET_NO == res: ignore, was simply not supported */
+    return;
+  }
+  /* NULL == address, last call, we are done */
+
+  rc->asc = NULL;
+  GNUNET_assert (address_resolutions > 0);
+  address_resolutions--;
+  if (GNUNET_NO == rc->printed)
+  {
+    if (numeric == GNUNET_NO)
+    {
+      /* Failed to resolve address, try numeric lookup
+         (note: this should not be needed, as transport
+         should fallback to numeric conversion if DNS takes
+         too long) */
+      resolve_peer_address (rc->addrcp,
+                            GNUNET_YES,
+                            rc->state,
+                            rc->state_timeout);
+    }
+    else
+    {
+      print_info (&rc->addrcp->peer,
+                  rc->transport,
+                  NULL,
+                  rc->state,
+                  rc->state_timeout);
+    }
+  }
+  GNUNET_free (rc->transport);
+  GNUNET_free (rc->addrcp);
+  GNUNET_CONTAINER_DLL_remove (rc_head, rc_tail, rc);
+  GNUNET_free (rc);
+  if ((0 == address_resolutions) && (iterate_connections))
+  {
+    if (NULL != op_timeout)
+    {
+      GNUNET_SCHEDULER_cancel (op_timeout);
+      op_timeout = NULL;
+    }
+    ret = 0;
+    GNUNET_SCHEDULER_shutdown ();
+  }
+}
+
+
+/**
+ * Convert address to a printable format and print it
+ * together with the given state data.
+ *
+ * @param address the address
+ * @param numeric #GNUNET_YES to convert to numeric format, #GNUNET_NO
+ *                to try to use reverse DNS
+ * @param state state the peer is in
+ * @param state_timeout when will the peer's state expire
+ */
+static void
+resolve_peer_address (const struct GNUNET_HELLO_Address *address,
+                      int numeric,
+                      enum GNUNET_TRANSPORT_PeerState state,
+                      struct GNUNET_TIME_Absolute state_timeout)
+{
+  struct PeerResolutionContext *rc;
+
+  rc = GNUNET_new (struct PeerResolutionContext);
+  GNUNET_CONTAINER_DLL_insert (rc_head, rc_tail, rc);
+  address_resolutions++;
+  rc->transport = GNUNET_strdup (address->transport_name);
+  rc->addrcp = GNUNET_HELLO_address_copy (address);
+  rc->printed = GNUNET_NO;
+  rc->state = state;
+  rc->state_timeout = state_timeout;
+  /* Resolve address to string */
+  rc->asc = GNUNET_TRANSPORT_address_to_string (cfg,
+                                                address,
+                                                numeric,
+                                                RESOLUTION_TIMEOUT,
+                                                &process_peer_string,
+                                                rc);
+}
+
+
+/**
+ * Function called with information about a peers during a one shot iteration
+ *
+ * @param cls closure
+ * @param peer identity of the peer, NULL for final callback when operation done
+ * @param address binary address used to communicate with this peer,
+ *  NULL on disconnect or when done
+ * @param state current state this peer is in
+ * @param state_timeout time out for the current state
+ */
+static void
+process_peer_iteration_cb (void *cls,
+                           const struct GNUNET_PeerIdentity *peer,
+                           const struct GNUNET_HELLO_Address *address,
+                           enum GNUNET_TRANSPORT_PeerState state,
+                           struct GNUNET_TIME_Absolute state_timeout)
+{
+  if (NULL == peer)
+  {
+    /* done */
+    pic = NULL;
+    return;
+  }
+
+  if ((GNUNET_NO == iterate_all) &&
+      (GNUNET_NO == GNUNET_TRANSPORT_is_connected (state)))
+    return; /* Display only connected peers */
+
+  if (NULL != op_timeout)
+    GNUNET_SCHEDULER_cancel (op_timeout);
+  op_timeout =
+    GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT, &operation_timeout, NULL);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received address for peer `%s': %s\n",
+              GNUNET_i2s (peer),
+              address ? address->transport_name : "");
+
+  if (NULL != address)
+    resolve_peer_address (address, numeric, state, state_timeout);
+  else
+    print_info (peer, NULL, NULL, state, state_timeout);
+}
+
+
+/**
+ * Context for address resolution by #plugin_monitoring_cb().
+ */
+struct PluginMonitorAddress
+{
+  /**
+   * Ongoing resolution request.
+   */
+  struct GNUNET_TRANSPORT_AddressToStringContext *asc;
+
+  /**
+   * Resolved address as string.
+   */
+  char *str;
+
+  /**
+   * Last event we got and did not yet print because
+   * @e str was NULL (address not yet resolved).
+   */
+  struct GNUNET_TRANSPORT_SessionInfo si;
+};
+
+
+/**
+ * Print information about a plugin monitoring event.
+ *
+ * @param addr out internal context
+ * @param info the monitoring information
+ */
+static void
+print_plugin_event_info (struct PluginMonitorAddress *addr,
+                         const struct GNUNET_TRANSPORT_SessionInfo *info)
+{
+  const char *state;
+
+  switch (info->state)
+  {
+  case GNUNET_TRANSPORT_SS_INIT:
+    state = "INIT";
+    break;
+
+  case GNUNET_TRANSPORT_SS_HANDSHAKE:
+    state = "HANDSHAKE";
+    break;
+
+  case GNUNET_TRANSPORT_SS_UP:
+    state = "UP";
+    break;
+
+  case GNUNET_TRANSPORT_SS_UPDATE:
+    state = "UPDATE";
+    break;
+
+  case GNUNET_TRANSPORT_SS_DONE:
+    state = "DONE";
+    break;
+
+  default:
+    state = "UNKNOWN";
+    break;
+  }
+  fprintf (stdout,
+           "%s: state %s timeout in %s @ %s%s\n",
+           GNUNET_i2s (&info->address->peer),
+           state,
+           GNUNET_STRINGS_relative_time_to_string (
+             GNUNET_TIME_absolute_get_remaining (info->session_timeout),
+             GNUNET_YES),
+           addr->str,
+           (info->is_inbound == GNUNET_YES) ? " (INBOUND)" : "");
+  fprintf (stdout,
+           "%s: queue has %3u messages and %6u bytes\n",
+           GNUNET_i2s (&info->address->peer),
+           info->num_msg_pending,
+           info->num_bytes_pending);
+  if (0 !=
+      GNUNET_TIME_absolute_get_remaining (info->receive_delay).rel_value_us)
+    fprintf (stdout,
+             "%s: receiving blocked until %s\n",
+             GNUNET_i2s (&info->address->peer),
+             GNUNET_STRINGS_absolute_time_to_string (info->receive_delay));
+}
+
+
+/**
+ * Function called with a textual representation of an address.  This
+ * function will be called several times with different possible
+ * textual representations, and a last time with @a address being NULL
+ * to signal the end of the iteration.  Note that @a address NULL
+ * always is the last call, regardless of the value in @a res.
+ *
+ * @param cls closure
+ * @param address NULL on end of iteration,
+ *        otherwise 0-terminated printable UTF-8 string,
+ *        in particular an empty string if @a res is #GNUNET_NO
+ * @param res result of the address to string conversion:
+ *        if #GNUNET_OK: conversion successful
+ *        if #GNUNET_NO: address was invalid (or not supported)
+ *        if #GNUNET_SYSERR: communication error (IPC error)
+ */
+static void
+address_cb (void *cls, const char *address, int res)
+{
+  struct PluginMonitorAddress *addr = cls;
+
+  if (NULL == address)
+  {
+    addr->asc = NULL;
+    return;
+  }
+  if (NULL != addr->str)
+    return;
+  addr->str = GNUNET_strdup (address);
+  print_plugin_event_info (addr, &addr->si);
+}
+
+
+/**
+ * Function called by the plugin with information about the
+ * current sessions managed by the plugin (for monitoring).
+ *
+ * @param cls closure (NULL)
+ * @param session session handle this information is about,
+ *        NULL to indicate that we are "in sync" (initial
+ *        iteration complete)
+ * @param session_ctx storage location where the application
+ *        can store data; will point to NULL on #GNUNET_TRANSPORT_SS_INIT,
+ *        and must be reset to NULL on #GNUNET_TRANSPORT_SS_DONE
+ * @param info information about the state of the session,
+ *        NULL if @a session is also NULL and we are
+ *        merely signalling that the initial iteration is over;
+ *        NULL with @a session being non-NULL if the monitor
+ *        was being cancelled while sessions were active
+ */
+static void
+plugin_monitoring_cb (void *cls,
+                      struct GNUNET_TRANSPORT_PluginSession *session,
+                      void **session_ctx,
+                      const struct GNUNET_TRANSPORT_SessionInfo *info)
+{
+  struct PluginMonitorAddress *addr;
+
+  if ((NULL == info) && (NULL == session))
+    return; /* in sync with transport service */
+  addr = *session_ctx;
+  if (NULL == info)
+  {
+    if (NULL != addr)
+    {
+      if (NULL != addr->asc)
+      {
+        GNUNET_TRANSPORT_address_to_string_cancel (addr->asc);
+        addr->asc = NULL;
+      }
+      GNUNET_free (addr->str);
+      GNUNET_free (addr);
+      *session_ctx = NULL;
+    }
+    return;   /* shutdown */
+  }
+  if (0 !=
+      memcmp (&info->address->peer, &pid, sizeof(struct GNUNET_PeerIdentity)))
+    return; /* filtered */
+  if (NULL == addr)
+  {
+    addr = GNUNET_new (struct PluginMonitorAddress);
+    addr->asc =
+      GNUNET_TRANSPORT_address_to_string (cfg,
+                                          info->address,
+                                          numeric,
+                                          GNUNET_TIME_UNIT_FOREVER_REL,
+                                          &address_cb,
+                                          addr);
+    *session_ctx = addr;
+  }
+  if (NULL == addr->str)
+    addr->si = *info;
+  else
+    print_plugin_event_info (addr, info);
+  if (GNUNET_TRANSPORT_SS_DONE == info->state)
+  {
+    if (NULL != addr->asc)
+    {
+      GNUNET_TRANSPORT_address_to_string_cancel (addr->asc);
+      addr->asc = NULL;
+    }
+    GNUNET_free (addr->str);
+    GNUNET_free (addr);
+    *session_ctx = NULL;
+  }
+}
+
+
+/**
+ * Function called with information about a peers
+ *
+ * @param cls closure, NULL
+ * @param peer identity of the peer, NULL for final callback when operation done
+ * @param address binary address used to communicate with this peer,
+ *  NULL on disconnect or when done
+ * @param state current state this peer is in
+ * @param state_timeout time out for the current state
+ */
+static void
+process_peer_monitoring_cb (void *cls,
+                            const struct GNUNET_PeerIdentity *peer,
+                            const struct GNUNET_HELLO_Address *address,
+                            enum GNUNET_TRANSPORT_PeerState state,
+                            struct GNUNET_TIME_Absolute state_timeout)
+{
+  struct MonitoredPeer *m;
+
+  if (NULL == peer)
+  {
+    fprintf (stdout,
+             "%s",
+             _ (
+               "Monitor disconnected from transport service. Reconnecting.\n"));
+    return;
+  }
+
+  if (NULL != op_timeout)
+    GNUNET_SCHEDULER_cancel (op_timeout);
+  op_timeout =
+    GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT, &operation_timeout, NULL);
+
+  if (NULL == (m = GNUNET_CONTAINER_multipeermap_get (monitored_peers, peer)))
+  {
+    m = GNUNET_new (struct MonitoredPeer);
+    GNUNET_CONTAINER_multipeermap_put (
+      monitored_peers,
+      peer,
+      m,
+      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+  }
+  else
+  {
+    if ((m->state == state) &&
+        (m->state_timeout.abs_value_us == state_timeout.abs_value_us) &&
+        (NULL == address) && (NULL == m->address))
+    {
+      return;     /* No real change */
+    }
+    if ((m->state == state) && (NULL != address) && (NULL != m->address) &&
+        (0 == GNUNET_HELLO_address_cmp (m->address, address)))
+      return;   /* No real change */
+  }
+
+  if (NULL != m->address)
+  {
+    GNUNET_free (m->address);
+    m->address = NULL;
+  }
+  if (NULL != address)
+    m->address = GNUNET_HELLO_address_copy (address);
+  m->state = state;
+  m->state_timeout = state_timeout;
+
+  if (NULL != address)
+    resolve_peer_address (m->address, numeric, m->state, m->state_timeout);
+  else
+    print_info (peer, NULL, NULL, m->state, m->state_timeout);
+}
+
+
+/**
+ * Function called with the transport service checking if we
+ * want to blacklist a peer. Return #GNUNET_SYSERR for the
+ * peer that we should disconnect from.
+ *
+ * @param cls NULL
+ * @param cpid peer to check blacklisting for
+ * @return #GNUNET_OK if the connection is allowed, #GNUNET_SYSERR if not
+ */
+static int
+blacklist_cb (void *cls, const struct GNUNET_PeerIdentity *cpid)
+{
+  if (0 == memcmp (cpid, &pid, sizeof(struct GNUNET_PeerIdentity)))
+    return GNUNET_SYSERR;
+  return GNUNET_OK;
+}
+
+
+/**
+ * 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 mycfg configuration
+ */
+static void
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *mycfg)
+{
+  static struct GNUNET_PeerIdentity zero_pid;
+  int counter = 0;
+
+  ret = 1;
+
+  cfg = (struct GNUNET_CONFIGURATION_Handle *) mycfg;
+
+  counter = benchmark_send + benchmark_receive + iterate_connections
+            + monitor_connections + monitor_connects + do_disconnect
+            + monitor_plugins;
+
+  if (1 < counter)
+  {
+    fprintf (
+      stderr,
+      _ (
+        "Multiple operations given. Please choose only one operation: %s, %s, %s, %s, %s, %s %s\n"),
+      "disconnect",
+      "benchmark send",
+      "benchmark receive",
+      "information",
+      "monitor",
+      "events",
+      "plugins");
+    return;
+  }
+  if (0 == counter)
+  {
+    fprintf (
+      stderr,
+      _ (
+        "No operation given. Please choose one operation: %s, %s, %s, %s, %s, %s, %s\n"),
+      "disconnect",
+      "benchmark send",
+      "benchmark receive",
+      "information",
+      "monitor",
+      "events",
+      "plugins");
+    return;
+  }
+
+  if (do_disconnect) /* -D: Disconnect from peer */
+  {
+    if (0 == memcmp (&zero_pid, &pid, sizeof(pid)))
+    {
+      fprintf (stderr,
+               _ ("Option `%s' makes no sense without option `%s'.\n"),
+               "-D",
+               "-p");
+      ret = 1;
+      return;
+    }
+    blacklist = GNUNET_TRANSPORT_blacklist (cfg, &blacklist_cb, NULL);
+    if (NULL == blacklist)
+    {
+      fprintf (stderr,
+               "%s",
+               _ (
+                 "Failed to connect to transport service for disconnection\n"));
+      ret = 1;
+      return;
+    }
+    fprintf (stdout,
+             "%s",
+             _ ("Blacklisting request in place, stop with CTRL-C\n"));
+  }
+  else if (benchmark_send) /* -s: Benchmark sending */
+  {
+    if (0 == memcmp (&zero_pid, &pid, sizeof(pid)))
+    {
+      fprintf (stderr,
+               _ ("Option `%s' makes no sense without option `%s'.\n"),
+               "-s",
+               "-p");
+      ret = 1;
+      return;
+    }
+    handle = GNUNET_TRANSPORT_core_connect (cfg,
+                                            NULL,
+                                            NULL,
+                                            NULL,
+                                            &notify_connect,
+                                            &notify_disconnect,
+                                            NULL);
+    if (NULL == handle)
+    {
+      fprintf (stderr, "%s", _ ("Failed to connect to transport service\n"));
+      ret = 1;
+      return;
+    }
+    start_time = GNUNET_TIME_absolute_get ();
+    op_timeout =
+      GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT, &operation_timeout, NULL);
+  }
+  else if (benchmark_receive) /* -b: Benchmark receiving */
+  {
+    struct GNUNET_MQ_MessageHandler handlers[] =
+    { GNUNET_MQ_hd_var_size (dummy,
+                             GNUNET_MESSAGE_TYPE_DUMMY,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+      GNUNET_MQ_handler_end () };
+
+    handle = GNUNET_TRANSPORT_core_connect (cfg,
+                                            NULL,
+                                            handlers,
+                                            NULL,
+                                            NULL,
+                                            NULL,
+                                            NULL);
+    if (NULL == handle)
+    {
+      fprintf (stderr, "%s", _ ("Failed to connect to transport service\n"));
+      ret = 1;
+      return;
+    }
+    if (verbosity > 0)
+      fprintf (stdout, "%s", _ ("Starting to receive benchmark data\n"));
+    start_time = GNUNET_TIME_absolute_get ();
+  }
+  else if (iterate_connections) /* -i: List information about peers once */
+  {
+    pic = GNUNET_TRANSPORT_monitor_peers (cfg,
+                                          &pid,
+                                          GNUNET_YES,
+                                          &process_peer_iteration_cb,
+                                          (void *) cfg);
+    op_timeout =
+      GNUNET_SCHEDULER_add_delayed (OP_TIMEOUT, &operation_timeout, NULL);
+  }
+  else if (monitor_connections) /* -m: List information about peers continuously
+                                 */
+  {
+    monitored_peers = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
+    pic = GNUNET_TRANSPORT_monitor_peers (cfg,
+                                          &pid,
+                                          GNUNET_NO,
+                                          &process_peer_monitoring_cb,
+                                          NULL);
+  }
+  else if (monitor_plugins) /* -P: List information about plugins continuously
+                             */
+  {
+    monitored_plugins = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
+    pm = GNUNET_TRANSPORT_monitor_plugins (cfg, &plugin_monitoring_cb, NULL);
+  }
+  else if (monitor_connects) /* -e : Monitor (dis)connect events continuously */
+  {
+    monitor_connect_counter = 0;
+    handle = GNUNET_TRANSPORT_core_connect (cfg,
+                                            NULL,
+                                            NULL,
+                                            NULL,
+                                            &monitor_notify_connect,
+                                            &monitor_notify_disconnect,
+                                            NULL);
+    if (NULL == handle)
+    {
+      fprintf (stderr, "%s", _ ("Failed to connect to transport service\n"));
+      ret = 1;
+      return;
+    }
+    ret = 0;
+  }
+  else
+  {
+    GNUNET_break (0);
+    return;
+  }
+
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
+}
+
+
+int
+main (int argc, char *const *argv)
+{
+  int res;
+  struct GNUNET_GETOPT_CommandLineOption options[] =
+  { GNUNET_GETOPT_option_flag (
+      'a',
+      "all",
+      gettext_noop (
+        "print information for all peers (instead of only connected peers)"),
+      &iterate_all),
+    GNUNET_GETOPT_option_flag (
+      'b',
+      "benchmark",
+      gettext_noop (
+        "measure how fast we are receiving data from all peers (until CTRL-C)"),
+      &benchmark_receive),
+    GNUNET_GETOPT_option_flag ('D',
+                               "disconnect",
+                               gettext_noop ("disconnect from a peer"),
+                               &do_disconnect),
+    GNUNET_GETOPT_option_flag (
+      'i',
+      "information",
+      gettext_noop (
+        "provide information about all current connections (once)"),
+      &iterate_connections),
+    GNUNET_GETOPT_option_flag (
+      'm',
+      "monitor",
+      gettext_noop (
+        "provide information about all current connections (continuously)"),
+      &monitor_connections),
+    GNUNET_GETOPT_option_flag (
+      'e',
+      "events",
+      gettext_noop (
+        "provide information about all connects and disconnect events (continuously)"),
+      &monitor_connects),
+    GNUNET_GETOPT_option_flag ('n',
+                               "numeric",
+                               gettext_noop ("do not resolve hostnames"),
+                               &numeric),
+    GNUNET_GETOPT_option_base32_auto ('p',
+                                      "peer",
+                                      "PEER",
+                                      gettext_noop ("peer identity"),
+                                      &pid),
+    GNUNET_GETOPT_option_flag ('P',
+                               "plugins",
+                               gettext_noop ("monitor plugin sessions"),
+                               &monitor_plugins),
+    GNUNET_GETOPT_option_flag (
+      's',
+      "send",
+      gettext_noop (
+        "send data for benchmarking to the other peer (until CTRL-C)"),
+      &benchmark_send),
+    GNUNET_GETOPT_option_verbose (&verbosity),
+    GNUNET_GETOPT_OPTION_END };
+
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
+    return 2;
+
+  res =
+    GNUNET_PROGRAM_run (argc,
+                        argv,
+                        "gnunet-transport",
+                        gettext_noop ("Direct access to transport service."),
+                        options,
+                        &run,
+                        NULL);
+  GNUNET_free_nz ((void *) argv);
+  if (GNUNET_OK == res)
+    return ret;
+  return 1;
+}
+
+
+/* end of gnunet-transport.c */
diff --git a/src/service/transport/ieee80211_radiotap.h b/src/service/transport/ieee80211_radiotap.h
new file mode 100644
index 000000000..9351da9a5
--- /dev/null
+++ b/src/service/transport/ieee80211_radiotap.h
@@ -0,0 +1,276 @@
+/*
+ * Copyright (c) 2003, 2004 David Young.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of David Young may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY DAVID YOUNG ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL DAVID
+ * YOUNG BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+ * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ */
+
+/*
+ * Modifications to fit into the linux IEEE 802.11 stack,
+ * Mike Kershaw (dragorn@kismetwireless.net)
+ */
+
+#ifndef IEEE80211RADIOTAP_H
+#define IEEE80211RADIOTAP_H
+
+#include <linux/if_ether.h>
+#include <linux/kernel.h>
+// #include <asm/unaligned.h>
+
+/* Base version of the radiotap packet header data */
+#define PKTHDR_RADIOTAP_VERSION         0
+
+/* A generic radio capture format is desirable. There is one for
+ * Linux, but it is neither rigidly defined (there were not even
+ * units given for some fields) nor easily extensible.
+ *
+ * I suggest the following extensible radio capture format. It is
+ * based on a bitmap indicating which fields are present.
+ *
+ * I am trying to describe precisely what the application programmer
+ * should expect in the following, and for that reason I tell the
+ * units and origin of each measurement (where it applies), or else I
+ * use sufficiently weaselly language ("is a monotonically nondecreasing
+ * function of...") that I cannot set false expectations for lawyerly
+ * readers.
+ */
+
+/*
+ * The radio capture header precedes the 802.11 header.
+ * All data in the header is little endian on all platforms.
+ */
+struct ieee80211_radiotap_header
+{
+  u8 it_version;                /* Version 0. Only increases
+                                 * for drastic changes,
+                                 * introduction of compatible
+                                 * new fields does not count.
+                                 */
+  u8 it_pad;
+  __le16 it_len;                /* length of the whole
+                                 * header in bytes, including
+                                 * it_version, it_pad,
+                                 * it_len, and data fields.
+                                 */
+  __le32 it_present;            /* A bitmap telling which
+                                 * fields are present. Set bit 31
+                                 * (0x80000000) to extend the
+                                 * bitmap by another 32 bits.
+                                 * Additional extensions are made
+                                 * by setting bit 31.
+                                 */
+} __packed;
+
+/* Name                                 Data type    Units
+ * ----                                 ---------    -----
+ *
+ * IEEE80211_RADIOTAP_TSFT              __le64       microseconds
+ *
+ *      Value in microseconds of the MAC's 64-bit 802.11 Time
+ *      Synchronization Function timer when the first bit of the
+ *      MPDU arrived at the MAC. For received frames, only.
+ *
+ * IEEE80211_RADIOTAP_CHANNEL           2 x __le16   MHz, bitmap
+ *
+ *      Tx/Rx frequency in MHz, followed by flags (see below).
+ *
+ * IEEE80211_RADIOTAP_FHSS              __le16       see below
+ *
+ *      For frequency-hopping radios, the hop set (first byte)
+ *      and pattern (second byte).
+ *
+ * IEEE80211_RADIOTAP_RATE              u8           500kb/s
+ *
+ *      Tx/Rx data rate
+ *
+ * IEEE80211_RADIOTAP_DBM_ANTSIGNAL     s8           decibels from
+ *                                                   one milliwatt (dBm)
+ *
+ *      RF signal power at the antenna, decibel difference from
+ *      one milliwatt.
+ *
+ * IEEE80211_RADIOTAP_DBM_ANTNOISE      s8           decibels from
+ *                                                   one milliwatt (dBm)
+ *
+ *      RF noise power at the antenna, decibel difference from one
+ *      milliwatt.
+ *
+ * IEEE80211_RADIOTAP_DB_ANTSIGNAL      u8           decibel (dB)
+ *
+ *      RF signal power at the antenna, decibel difference from an
+ *      arbitrary, fixed reference.
+ *
+ * IEEE80211_RADIOTAP_DB_ANTNOISE       u8           decibel (dB)
+ *
+ *      RF noise power at the antenna, decibel difference from an
+ *      arbitrary, fixed reference point.
+ *
+ * IEEE80211_RADIOTAP_LOCK_QUALITY      __le16       unitless
+ *
+ *      Quality of Barker code lock. Unitless. Monotonically
+ *      nondecreasing with "better" lock strength. Called "Signal
+ *      Quality" in datasheets.  (Is there a standard way to measure
+ *      this?)
+ *
+ * IEEE80211_RADIOTAP_TX_ATTENUATION    __le16       unitless
+ *
+ *      Transmit power expressed as unitless distance from max
+ *      power set at factory calibration.  0 is max power.
+ *      Monotonically nondecreasing with lower power levels.
+ *
+ * IEEE80211_RADIOTAP_DB_TX_ATTENUATION __le16       decibels (dB)
+ *
+ *      Transmit power expressed as decibel distance from max power
+ *      set at factory calibration.  0 is max power.  Monotonically
+ *      nondecreasing with lower power levels.
+ *
+ * IEEE80211_RADIOTAP_DBM_TX_POWER      s8           decibels from
+ *                                                   one milliwatt (dBm)
+ *
+ *      Transmit power expressed as dBm (decibels from a 1 milliwatt
+ *      reference). This is the absolute power level measured at
+ *      the antenna port.
+ *
+ * IEEE80211_RADIOTAP_FLAGS             u8           bitmap
+ *
+ *      Properties of transmitted and received frames. See flags
+ *      defined below.
+ *
+ * IEEE80211_RADIOTAP_ANTENNA           u8           antenna index
+ *
+ *      Unitless indication of the Rx/Tx antenna for this packet.
+ *      The first antenna is antenna 0.
+ *
+ * IEEE80211_RADIOTAP_RX_FLAGS          __le16       bitmap
+ *
+ *     Properties of received frames. See flags defined below.
+ *
+ * IEEE80211_RADIOTAP_TX_FLAGS          __le16       bitmap
+ *
+ *     Properties of transmitted frames. See flags defined below.
+ *
+ * IEEE80211_RADIOTAP_RTS_RETRIES       u8           data
+ *
+ *     Number of rts retries a transmitted frame used.
+ *
+ * IEEE80211_RADIOTAP_DATA_RETRIES      u8           data
+ *
+ *     Number of unicast retries a transmitted frame used.
+ *
+ */
+enum ieee80211_radiotap_type
+{
+  IEEE80211_RADIOTAP_TSFT = 0,
+  IEEE80211_RADIOTAP_FLAGS = 1,
+  IEEE80211_RADIOTAP_RATE = 2,
+  IEEE80211_RADIOTAP_CHANNEL = 3,
+  IEEE80211_RADIOTAP_FHSS = 4,
+  IEEE80211_RADIOTAP_DBM_ANTSIGNAL = 5,
+  IEEE80211_RADIOTAP_DBM_ANTNOISE = 6,
+  IEEE80211_RADIOTAP_LOCK_QUALITY = 7,
+  IEEE80211_RADIOTAP_TX_ATTENUATION = 8,
+  IEEE80211_RADIOTAP_DB_TX_ATTENUATION = 9,
+  IEEE80211_RADIOTAP_DBM_TX_POWER = 10,
+  IEEE80211_RADIOTAP_ANTENNA = 11,
+  IEEE80211_RADIOTAP_DB_ANTSIGNAL = 12,
+  IEEE80211_RADIOTAP_DB_ANTNOISE = 13,
+  IEEE80211_RADIOTAP_RX_FLAGS = 14,
+  IEEE80211_RADIOTAP_TX_FLAGS = 15,
+  IEEE80211_RADIOTAP_RTS_RETRIES = 16,
+  IEEE80211_RADIOTAP_DATA_RETRIES = 17,
+
+  /* valid in every it_present bitmap, even vendor namespaces */
+  IEEE80211_RADIOTAP_RADIOTAP_NAMESPACE = 29,
+  IEEE80211_RADIOTAP_VENDOR_NAMESPACE = 30,
+  IEEE80211_RADIOTAP_EXT = 31
+};
+
+/* Channel flags. */
+#define IEEE80211_CHAN_TURBO    0x0010  /* Turbo channel */
+#define IEEE80211_CHAN_CCK      0x0020  /* CCK channel */
+#define IEEE80211_CHAN_OFDM     0x0040  /* OFDM channel */
+#define IEEE80211_CHAN_2GHZ     0x0080  /* 2 GHz spectrum channel. */
+#define IEEE80211_CHAN_5GHZ     0x0100  /* 5 GHz spectrum channel */
+#define IEEE80211_CHAN_PASSIVE  0x0200  /* Only passive scan allowed */
+#define IEEE80211_CHAN_DYN      0x0400  /* Dynamic CCK-OFDM channel */
+#define IEEE80211_CHAN_GFSK     0x0800  /* GFSK channel (FHSS PHY) */
+
+/* For IEEE80211_RADIOTAP_FLAGS */
+#define IEEE80211_RADIOTAP_F_CFP        0x01    /* sent/received
+                                                 * during CFP
+                                                 */
+#define IEEE80211_RADIOTAP_F_SHORTPRE   0x02    /* sent/received
+                                                 * with short
+                                                 * preamble
+                                                 */
+#define IEEE80211_RADIOTAP_F_WEP        0x04    /* sent/received
+                                                 * with WEP encryption
+                                                 */
+#define IEEE80211_RADIOTAP_F_FRAG       0x08    /* sent/received
+                                                 * with fragmentation
+                                                 */
+#define IEEE80211_RADIOTAP_F_FCS        0x10    /* frame includes FCS */
+#define IEEE80211_RADIOTAP_F_DATAPAD    0x20    /* frame has padding between
+                                                 * 802.11 header and payload
+                                                 * (to 32-bit boundary)
+                                                 */
+#define IEEE80211_RADIOTAP_F_BADFCS     0x40    /* bad FCS */
+
+/* For IEEE80211_RADIOTAP_RX_FLAGS */
+#define IEEE80211_RADIOTAP_F_RX_BADPLCP 0x0002  /* frame has bad PLCP */
+
+/* For IEEE80211_RADIOTAP_TX_FLAGS */
+#define IEEE80211_RADIOTAP_F_TX_FAIL    0x0001  /* failed due to excessive
+                                                 * retries */
+#define IEEE80211_RADIOTAP_F_TX_CTS     0x0002  /* used cts 'protection' */
+#define IEEE80211_RADIOTAP_F_TX_RTS     0x0004  /* used rts/cts handshake */
+
+/* Ugly macro to convert literal channel numbers into their mhz equivalents
+ * There are certainly some conditions that will break this (like feeding it '30')
+ * but they shouldn't arise since nothing talks on channel 30. */
+#define ieee80211chan2mhz(x) \
+  (((x) <= 14) ? \
+   (((x) == 14) ? 2484 : ((x) * 5) + 2407) : \
+   ((x) + 1000) * 5)
+
+/* helpers */
+static inline u16
+get_unaligned_le16 (const u8 *p)
+{
+  return p[0] | p[1] << 8;
+}
+
+
+static inline int
+ieee80211_get_radiotap_len (unsigned char *data)
+{
+  struct ieee80211_radiotap_header *hdr =
+    (struct ieee80211_radiotap_header *) data;
+
+  return get_unaligned_le16 ((const u8 *) &hdr->it_len);
+}
+
+
+#endif /* IEEE80211_RADIOTAP_H */
diff --git a/src/service/transport/meson.build b/src/service/transport/meson.build
new file mode 100644
index 000000000..b46496b43
--- /dev/null
+++ b/src/service/transport/meson.build
@@ -0,0 +1,491 @@
+libgnunettransportapplication_src = ['transport_api2_application.c']
+libgnunettransportcore_src = ['transport_api2_core.c']
+libgnunettransportcommunicator_src = ['transport_api2_communication.c']
+libgnunettransportmonitor_src = ['transport_api2_monitor.c']
+
+gnunetservicetransport_src = ['gnunet-service-transport.c']
+gnunetcommunicatortcp_src = ['gnunet-communicator-tcp.c']
+gnunetcommunicatorudp_src = ['gnunet-communicator-udp.c']
+gnunetcommunicatorunix_src = ['gnunet-communicator-unix.c']
+
+configure_file(input : 'transport.conf.in',
+               output : 'transport.conf',
+               configuration : cdata,
+               install: true,
+               install_dir: pkgcfgdir)
+
+configure_file(input : 'gnunet-transport-certificate-creation.in',
+               output : 'gnunet-transport-certificate-creation',
+               configuration : cdata,
+               install: true,
+               install_dir: get_option('bindir'))
+
+if get_option('monolith')
+  foreach p : libgnunettransportapplication_src + libgnunettransportcore_src + libgnunettransportcommunicator_src + libgnunettransportmonitor_src + gnunetservicetransport_src
+    gnunet_src += 'transport/' + p
+  endforeach
+endif
+
+libgnunettransportapplication = library('gnunettransportapplication',
+                                        libgnunettransportapplication_src,
+                                        soversion: '0',
+                                        version: '0.0.0',
+                                        dependencies: libgnunetutil_dep,
+                                        include_directories: [incdir, configuration_inc],
+                                        install: true,
+                                        install_dir: get_option('libdir'))
+pkg.generate(libgnunettransportapplication, url: 'https://www.gnunet.org',
+             description : 'Provides application APIs for accessing the transport service')
+libgnunettransportapplication_dep = declare_dependency(link_with : libgnunettransportapplication)
+
+libgnunettransportcore = library('gnunettransportcore',
+                                 libgnunettransportcore_src,
+                                 soversion: '0',
+                                 version: '0.0.0',
+                                 dependencies: libgnunetutil_dep,
+                                 include_directories: [incdir, configuration_inc],
+                                 install: true,
+                                 install_dir: get_option('libdir'))
+pkg.generate(libgnunettransportcore, url: 'https://www.gnunet.org',
+             description : 'Provides core API for accessing the transport service')
+libgnunettransportcore_dep = declare_dependency(link_with : libgnunettransportcore)
+
+libgnunettransportcommunicator = library('gnunettransportcommunicator',
+                                         libgnunettransportcommunicator_src,
+                                         soversion: '0',
+                                         version: '0.0.0',
+                                         dependencies: libgnunetutil_dep,
+                                         include_directories: [incdir, configuration_inc],
+                                         install: true,
+                                         install_dir: get_option('libdir'))
+pkg.generate(libgnunettransportcommunicator, url: 'https://www.gnunet.org',
+             description : 'Provides communicator API for accessing the transport service')
+libgnunettransportcommunicator_dep = declare_dependency(link_with : libgnunettransportcommunicator)
+
+libgnunettransportmonitor = library('gnunettransportmonitor',
+                                    libgnunettransportmonitor_src,
+                                    soversion: '0',
+                                    version: '0.0.0',
+                                    dependencies: libgnunetutil_dep,
+                                    include_directories: [incdir, configuration_inc],
+                                    install: true,
+                                    install_dir: get_option('libdir'))
+pkg.generate(libgnunettransportmonitor, url: 'https://www.gnunet.org',
+             description : 'Provides monitor API for accessing the transport service')
+libgnunettransportmonitor_dep = declare_dependency(link_with : libgnunettransportmonitor)
+
+libgnunettestingtransport = library('gnunettestingtransport',
+                                     [
+                                       'testing_transport_traits.c'
+                                     ],
+                                     soversion: '0',
+                                     version: '0.0.0',
+                                     dependencies: [libgnunetutil_dep,
+                                                    libgnunettransportcore_dep,
+                                                    libgnunettransportapplication_dep,
+                                                    libgnunetpeerstore_dep,
+                                                    libgnunettesting_dep,
+                                                    libgnunethello_dep],
+                                     include_directories: [incdir, configuration_inc],
+                                     install: true,
+                                     install_dir: get_option('libdir'))
+libgnunettestingtransport_dep = declare_dependency(link_with : libgnunettestingtransport)
+
+executable ('gnunet-service-transport',
+            gnunetservicetransport_src,
+            dependencies: [libgnunettransportcommunicator_dep,
+                           libgnunetpeerstore_dep,
+                           libgnunetstatistics_dep,
+                           libgnunethello_dep,
+                           libgnunetnat_dep,
+                           gcrypt_dep,
+                           m_dep,
+                           libgnunetutil_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+
+executable ('gnunet-communicator-unix',
+            gnunetcommunicatorunix_src,
+            dependencies: [libgnunettransportcommunicator_dep,
+                           libgnunetpeerstore_dep,
+                           libgnunetstatistics_dep,
+                           libgnunetnat_dep,
+                           gcrypt_dep,
+                           libgnunetutil_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+executable ('gnunet-communicator-udp',
+            gnunetcommunicatorudp_src,
+            dependencies: [libgnunettransportcommunicator_dep,
+                           libgnunettransportapplication_dep,
+                           libgnunetpeerstore_dep,
+                           libgnunetstatistics_dep,
+                           libgnunetnat_dep,
+                           gcrypt_dep,
+                           libgnunetutil_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+executable ('gnunet-communicator-tcp',
+            gnunetcommunicatortcp_src,
+            dependencies: [libgnunettransportcommunicator_dep,
+                           libgnunetpeerstore_dep,
+                           libgnunetstatistics_dep,
+                           libgnunetnat_dep,
+                           gcrypt_dep,
+                           libgnunetutil_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+if quic_dep.found() and get_option('experimental')
+executable ('gnunet-communicator-quic',
+            gnunetcommunicatortcp_src,
+            dependencies: [libgnunettransportcommunicator_dep,
+                           libgnunetpeerstore_dep,
+                           libgnunetstatistics_dep,
+                           libgnunetnat_dep,
+                           gcrypt_dep,
+                           quic_dep,
+                           libgnunetutil_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+endif
+
+if false
+
+libgnunettesttransport_cmd_simplesend = library('gnunet_test_transport_plugin_cmd_simple_send',
+                                                ['test_transport_plugin_cmd_simple_send.c'],
+                                                dependencies: [
+                                                  libgnunetutil_dep,
+                                                  libgnunettransportapplication_dep,
+                                                  libgnunettestingtransport_dep,
+                                                  libgnunettransportcore_dep,
+                                                  libgnunettesting_dep,
+                                                  libgnunetpeerstore_dep,
+                                                  libgnunetstatistics_dep,
+                                                  libgnunethello_dep,
+                                                  libgnunetarm_dep,
+                                                  libgnunetutil_dep
+                                                ],
+                                                include_directories: [incdir, configuration_inc],
+                                                install: true,
+                                                install_dir: get_option('libdir')/'gnunet')
+
+libgnunettesttransport_cmd_simplesendbc = library('gnunet_test_transport_plugin_cmd_simple_send_broadcast',
+                                                  ['test_transport_plugin_cmd_simple_send_broadcast.c'],
+                                                  dependencies: [
+                                                    libgnunetutil_dep,
+                                                    libgnunettransportapplication_dep,
+                                                    libgnunettestingtransport_dep,
+                                                    libgnunettransportcore_dep,
+                                                    libgnunettesting_dep,
+                                                    libgnunetpeerstore_dep,
+                                                    libgnunetstatistics_dep,
+                                                    libgnunethello_dep,
+                                                    libgnunetarm_dep,
+                                                    libgnunetutil_dep
+                                                  ],
+                                                  include_directories: [incdir, configuration_inc],
+                                                  install: true,
+                                                  install_dir: get_option('libdir')/'gnunet')
+
+libgnunettesttransport_cmd_simplesenddv = library('gnunet_test_transport_plugin_cmd_simple_send_dv',
+                                                  ['test_transport_plugin_cmd_simple_send_dv.c'],
+                                                  dependencies: [
+                                                    libgnunetutil_dep,
+                                                    libgnunettransportapplication_dep,
+                                                    libgnunettestingtransport_dep,
+                                                    libgnunettransportcore_dep,
+                                                    libgnunettesting_dep,
+                                                    libgnunetpeerstore_dep,
+                                                    libgnunetstatistics_dep,
+                                                    libgnunethello_dep,
+                                                    libgnunetarm_dep,
+                                                    libgnunetutil_dep
+                                                  ],
+                                                  include_directories: [incdir, configuration_inc],
+                                                  install: true,
+                                                  install_dir: get_option('libdir')/'gnunet')
+
+libgnunettesttransport_cmd_simplesendperf = library('gnunet_test_transport_plugin_cmd_simple_send_performance',
+                                                    ['test_transport_plugin_cmd_simple_send_performance.c'],
+                                                    dependencies: [
+                                                      libgnunetutil_dep,
+                                                      libgnunettransportapplication_dep,
+                                                      libgnunettestingtransport_dep,
+                                                      libgnunettransportcore_dep,
+                                                      libgnunettesting_dep,
+                                                      libgnunetpeerstore_dep,
+                                                      libgnunetstatistics_dep,
+                                                      libgnunethello_dep,
+                                                      libgnunetarm_dep,
+                                                      libgnunetutil_dep
+                                                    ],
+                                                    include_directories: [incdir, configuration_inc],
+                                                    install: true,
+                                                    install_dir: get_option('libdir')/'gnunet')
+
+libgnunettesttransport_cmd_udpback = library('gnunet_test_transport_plugin_cmd_udp_backchannel',
+                                             ['test_transport_plugin_cmd_udp_backchannel.c'],
+                                             dependencies: [
+                                               libgnunetutil_dep,
+                                               libgnunettestingtransport_dep,
+                                               libgnunettransportapplication_dep,
+                                               libgnunettransportcore_dep,
+                                               libgnunettesting_dep,
+                                               libgnunetpeerstore_dep,
+                                               libgnunetstatistics_dep,
+                                               libgnunethello_dep,
+                                               libgnunetarm_dep,
+                                               libgnunetutil_dep
+                                             ],
+                                             include_directories: [incdir, configuration_inc],
+                                             install: true,
+                                             install_dir: get_option('libdir')/'gnunet')
+
+libgnunettesttransport_cmd_natupnp = library('gnunet_test_transport_plugin_cmd_nat_upnp',
+                                             ['test_transport_plugin_cmd_nat_upnp.c'],
+                                             dependencies: [
+                                               libgnunetutil_dep,
+                                               libgnunettransportapplication_dep,
+                                               libgnunettestingtransport_dep,
+                                               libgnunettransportcore_dep,
+                                               libgnunettesting_dep,
+                                               libgnunetpeerstore_dep,
+                                               libgnunetstatistics_dep,
+                                               libgnunethello_dep,
+                                               libgnunetarm_dep,
+                                               libgnunetutil_dep
+                                             ],
+                                             include_directories: [incdir, configuration_inc],
+                                             install: true,
+                                             install_dir: get_option('libdir')/'gnunet')
+
+configure_file(input : 'test_transport_defaults.conf',
+               output : 'test_transport_defaults.conf',
+               copy: true)
+
+foreach p : ['unix', 'tcp', 'udp', 'quic']
+  configure_file(input : 'test_communicator_'+p+'_basic_peer1.conf',
+                 output : 'test_communicator_'+p+'_basic_peer1.conf',
+                 copy: true)
+  configure_file(input : 'test_communicator_'+p+'_basic_peer2.conf',
+                 output : 'test_communicator_'+p+'_basic_peer2.conf',
+                 copy: true)
+endforeach
+
+foreach p : ['tcp', 'udp']
+  configure_file(input : 'test_communicator_'+p+'_rekey_peer1.conf',
+                 output : 'test_communicator_'+p+'_rekey_peer1.conf',
+                 copy: true)
+  configure_file(input : 'test_communicator_'+p+'_rekey_peer2.conf',
+                 output : 'test_communicator_'+p+'_rekey_peer2.conf',
+                 copy: true)
+endforeach
+
+configure_file(input : 'test_communicator_udp_backchannel_peer1.conf',
+               output : 'test_communicator_udp_backchannel_peer1.conf',
+               copy: true)
+configure_file(input : 'test_communicator_udp_backchannel_peer2.conf',
+               output : 'test_communicator_udp_backchannel_peer2.conf',
+               copy: true)
+
+configure_file(input : 'test_communicator_tcp_bidirect_peer1.conf',
+               output : 'test_communicator_tcp_bidirect_peer1.conf',
+               copy: true)
+configure_file(input : 'test_communicator_tcp_bidirect_peer2.conf',
+               output : 'test_communicator_tcp_bidirect_peer2.conf',
+               copy: true)
+
+testcommunicator_basic_unix = executable('test_communicator_basic-unix',
+                                         ['test_communicator_basic.c'],
+                                         dependencies: [
+                                           libgnunetutil_dep,
+                                           libgnunettransportapplication_dep,
+                                           libgnunettestingtransport_dep,
+                                           libgnunettransportcore_dep,
+                                           libgnunettesting_dep,
+                                           libgnunetpeerstore_dep,
+                                           libgnunetstatistics_dep,
+                                           libgnunethello_dep,
+                                           libgnunetarm_dep,
+                                           libgnunetutil_dep
+                                         ],
+                                         include_directories: [incdir, configuration_inc],
+                                         install: false)
+testcommunicator_basic_tcp = executable('test_communicator_basic-tcp',
+                                        ['test_communicator_basic.c'],
+                                        dependencies: [
+                                          libgnunetutil_dep,
+                                          libgnunettransportapplication_dep,
+                                          libgnunettestingtransport_dep,
+                                          libgnunettransportcore_dep,
+                                          libgnunettesting_dep,
+                                          libgnunetpeerstore_dep,
+                                          libgnunetstatistics_dep,
+                                          libgnunethello_dep,
+                                          libgnunetarm_dep,
+                                          libgnunetutil_dep
+                                        ],
+                                        include_directories: [incdir, configuration_inc],
+                                        install: false)
+testcommunicator_basic_udp = executable('test_communicator_basic-udp',
+                                        ['test_communicator_basic.c'],
+                                        dependencies: [
+                                          libgnunetutil_dep,
+                                          libgnunettransportapplication_dep,
+                                          libgnunettestingtransport_dep,
+                                          libgnunettransportcore_dep,
+                                          libgnunettesting_dep,
+                                          libgnunetpeerstore_dep,
+                                          libgnunetstatistics_dep,
+                                          libgnunethello_dep,
+                                          libgnunetarm_dep,
+                                          libgnunetutil_dep
+                                        ],
+                                        include_directories: [incdir, configuration_inc],
+                                        install: false)
+if quic_dep.found() and get_option('experimental')
+  testcommunicator_basic_quic = executable('test_communicator_basic-quic',
+                                           ['test_communicator_basic.c'],
+                                           dependencies: [
+                                             libgnunetutil_dep,
+                                             libgnunettransportapplication_dep,
+                                             libgnunettestingtransport_dep,
+                                             libgnunettransportcore_dep,
+                                             libgnunettesting_dep,
+                                             libgnunetpeerstore_dep,
+                                             libgnunetstatistics_dep,
+                                             libgnunethello_dep,
+                                             libgnunetarm_dep,
+                                             libgnunetutil_dep
+                                           ],
+                                           include_directories: [incdir, configuration_inc],
+                                           install: false)
+endif
+
+testcommunicator_rekey_tcp = executable('test_communicator_rekey-tcp',
+                                        ['test_communicator_basic.c'],
+                                        dependencies: [
+                                          libgnunetutil_dep,
+                                          libgnunettransportapplication_dep,
+                                          libgnunettestingtransport_dep,
+                                          libgnunettransportcore_dep,
+                                          libgnunettesting_dep,
+                                          libgnunetpeerstore_dep,
+                                          libgnunetstatistics_dep,
+                                          libgnunethello_dep,
+                                          libgnunetarm_dep,
+                                          libgnunetutil_dep
+                                        ],
+                                        include_directories: [incdir, configuration_inc],
+                                        install: false)
+
+testcommunicator_rekey_udp = executable('test_communicator_rekey-udp',
+                                        ['test_communicator_basic.c'],
+                                        dependencies: [
+                                          libgnunetutil_dep,
+                                          libgnunettransportapplication_dep,
+                                          libgnunettestingtransport_dep,
+                                          libgnunettransportcore_dep,
+                                          libgnunettesting_dep,
+                                          libgnunetpeerstore_dep,
+                                          libgnunetstatistics_dep,
+                                          libgnunethello_dep,
+                                          libgnunetarm_dep,
+                                          libgnunetutil_dep
+                                        ],
+                                        include_directories: [incdir, configuration_inc],
+                                        install: false)
+
+testcommunicator_backchannel_udp = executable('test_communicator_backchannel-udp',
+                                              ['test_communicator_basic.c'],
+                                              dependencies: [
+                                                libgnunetutil_dep,
+                                                libgnunettransportapplication_dep,
+                                                libgnunettestingtransport_dep,
+                                                libgnunettransportcore_dep,
+                                                libgnunettesting_dep,
+                                                libgnunetpeerstore_dep,
+                                                libgnunetstatistics_dep,
+                                                libgnunethello_dep,
+                                                libgnunetarm_dep,
+                                                libgnunetutil_dep
+                                              ],
+                                              include_directories: [incdir, configuration_inc],
+                                              install: false)
+
+testcommunicator_bidirect_tcp = executable('test_communicator_bidirect-tcp',
+                                           ['test_communicator_basic.c'],
+                                           dependencies: [
+                                             libgnunetutil_dep,
+                                             libgnunettransportapplication_dep,
+                                             libgnunettestingtransport_dep,
+                                             libgnunettransportcore_dep,
+                                             libgnunettesting_dep,
+                                             libgnunetpeerstore_dep,
+                                             libgnunetstatistics_dep,
+                                             libgnunethello_dep,
+                                             libgnunetarm_dep,
+                                             libgnunetutil_dep
+                                           ],
+                                           include_directories: [incdir, configuration_inc],
+                                           install: false)
+
+
+testtransport_test_names = [
+    'test_transport_start_testcase',
+    'test_transport_simple_send_performance',
+    'test_transport_nat_icmp_tcp',
+    'test_transport_nat_upnp',
+    'test_transport_simple_send_string',
+    'test_transport_simple_send',
+    'test_transport_simple_send_broadcast',
+    'test_transport_udp_backchannel',
+    'test_transport_simple_send_dv_circle',
+    'test_transport_simple_send_dv_inverse'
+  ]
+
+foreach t : testtransport_test_names
+
+  test_filename = t + '.sh'
+  test_file = configure_file(input : test_filename,
+                             output : test_filename,
+                             copy: true)
+
+  if host_machine.system() != 'darwin'
+    test(t, test_file, suite: 'transport', workdir: meson.current_build_dir(), is_parallel: false)
+  endif
+endforeach
+
+test('test_communicator_basic-unix', testcommunicator_basic_unix,
+     workdir: meson.current_build_dir(),
+     suite: ['transport', 'communicator'], is_parallel: false)
+test('test_communicator_basic-tcp', testcommunicator_basic_tcp,
+     workdir: meson.current_build_dir(),
+     suite: ['transport', 'communicator'], is_parallel: false)
+test('test_communicator_basic-udp', testcommunicator_basic_udp,
+     workdir: meson.current_build_dir(),
+     suite: ['transport', 'communicator'], is_parallel: false)
+if quic_dep.found() and get_option('experimental')
+  test('test_communicator_basic-quic', testcommunicator_basic_quic,
+       workdir: meson.current_build_dir(),
+       suite: ['transport', 'communicator'], is_parallel: false)
+endif
+test('test_communicator_rekey-tcp', testcommunicator_rekey_tcp,
+     workdir: meson.current_build_dir(),
+     suite: ['transport', 'communicator'], is_parallel: false)
+test('test_communicator_rekey-udp', testcommunicator_rekey_udp,
+     workdir: meson.current_build_dir(),
+     suite: ['transport', 'communicator'], is_parallel: false)
+test('test_communicator_backchannel-udp', testcommunicator_backchannel_udp,
+     workdir: meson.current_build_dir(),
+     suite: ['transport', 'communicator'], is_parallel: false)
+test('test_communicator_bidirect-tcp', testcommunicator_bidirect_tcp,
+     workdir: meson.current_build_dir(),
+     suite: ['transport', 'communicator'], is_parallel: false)
+
+endif
\ No newline at end of file
diff --git a/src/service/transport/template_cfg_peer1.conf b/src/service/transport/template_cfg_peer1.conf
new file mode 100644
index 000000000..5ba198450
--- /dev/null
+++ b/src/service/transport/template_cfg_peer1.conf
@@ -0,0 +1,50 @@
+@INLINE@ test_transport_defaults.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-p1/
+GNUNET_RUNTIME_DIR = $GNUNET_TEST_HOME/runtime/
+GNUNET_USER_RUNTIME_DIR = $GNUNET_TEST_HOME/runtime/
+
+[nat]
+RETURN_LOCAL_ADDRESSES = YES
+DISABLEV6 = NO
+
+[transport-tcp]
+PORT = 12000
+TIMEOUT = 5 s
+
+[transport-udp]
+BROADCAST = NO
+
+[transport-unix]
+PORT = 12007
+
+[arm]
+PORT = 12005
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-arm.sock
+
+[statistics]
+PORT = 12004
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-statistics.sock
+
+[resolver]
+PORT = 12003
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-resolver.sock
+
+[peerinfo]
+PORT = 12002
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-peerinfo.sock
+USE_INCLUDED_HELLOS = NO
+
+[transport]
+#PREFIX = valgrind --leak-check=full
+PORT = 12001
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-transport.sock
+
+[ats]
+WAN_QUOTA_IN = unlimited
+WAN_QUOTA_OUT = unlimited
+PORT = 12006
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-ats.sock
+
+[hostlist]
+SERVERS = dummy
diff --git a/src/service/transport/template_cfg_peer2.conf b/src/service/transport/template_cfg_peer2.conf
new file mode 100644
index 000000000..6ac610fec
--- /dev/null
+++ b/src/service/transport/template_cfg_peer2.conf
@@ -0,0 +1,58 @@
+@INLINE@ test_transport_defaults.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-p2/
+GNUNET_RUNTIME_DIR = $GNUNET_TEST_HOME/runtime/
+GNUNET_USER_RUNTIME_DIR = $GNUNET_TEST_HOME/runtime/
+
+[nat]
+RETURN_LOCAL_ADDRESSES = YES
+DISABLEV6 = NO
+
+[transport-tcp]
+PORT = 12100
+TIMEOUT = 5 s
+
+[transport-udp]
+BROADCAST = NO
+
+[transport-unix]
+PORT = 12017
+
+[transport-http_server]
+PORT = 12018
+USE_IPv6 = YES
+
+[transport-https_server]
+PORT = 12019
+KEY_FILE = $GNUNET_TEST_HOME/https_key_p1.key
+CERT_FILE = $GNUNET_TEST_HOME/https_cert_p1.crt
+USE_IPv6 = YES
+
+[arm]
+PORT = 12014
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-arm.sock
+
+[statistics]
+PORT = 12013
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-statistics.sock
+
+[resolver]
+PORT = 12012
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-resolver.sock
+
+[peerinfo]
+PORT = 12011
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-peerinfo.sock
+USE_INCLUDED_HELLOS = NO
+
+[transport]
+#PREFIX = valgrind --leak-check=full
+PORT = 12010
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-transport.sock
+
+[ats]
+PORT = 12016
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-ats.sock
+
+[hostlist]
+SERVERS = dummy
diff --git a/src/service/transport/template_tng_cfg_peer1.conf b/src/service/transport/template_tng_cfg_peer1.conf
new file mode 100644
index 000000000..b6198d72c
--- /dev/null
+++ b/src/service/transport/template_tng_cfg_peer1.conf
@@ -0,0 +1,34 @@
+@INLINE@ test_tng_defaults.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-p1/
+GNUNET_RUNTIME_DIR = $GNUNET_TEST_HOME/runtime/
+GNUNET_USER_RUNTIME_DIR = $GNUNET_TEST_HOME/runtime/
+
+[nat]
+RETURN_LOCAL_ADDRESSES = YES
+DISABLEV6 = NO
+
+[arm]
+PORT = 12005
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-arm.sock
+
+[statistics]
+PORT = 12004
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-statistics.sock
+
+[resolver]
+PORT = 12003
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-resolver.sock
+
+[peerinfo]
+PORT = 12002
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-peerinfo.sock
+USE_INCLUDED_HELLOS = NO
+
+[transport]
+#PREFIX = valgrind --leak-check=full
+PORT = 12001
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-transport.sock
+
+[hostlist]
+SERVERS = dummy
diff --git a/src/service/transport/test_communicator_basic.c b/src/service/transport/test_communicator_basic.c
new file mode 100644
index 000000000..78ac26b25
--- /dev/null
+++ b/src/service/transport/test_communicator_basic.c
@@ -0,0 +1,1266 @@
+/*
+    This file is part of GNUnet.
+    Copyright (C) 2019 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 transport/test_communicator_basic.c
+* @brief test the communicators
+* @author Julius Bünger
+* @author Martin Schanzenbach
+*/
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "transport-testing-communicator.h"
+#include "gnunet_signatures.h"
+#include "gnunet_testing_lib.h"
+#include "transport.h"
+#include "gnunet_statistics_service.h"
+
+#include <inttypes.h>
+
+
+#define LOG(kind, ...) GNUNET_log_from (kind, \
+                                        "test_transport_communicator", \
+                                        __VA_ARGS__)
+
+#define NUM_PEERS 2
+
+static struct GNUNET_SCHEDULER_Task *to_task[NUM_PEERS];
+
+static int queue_est = GNUNET_NO;
+
+static struct GNUNET_PeerIdentity peer_id[NUM_PEERS];
+
+static char *communicator_binary;
+
+static struct
+GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_hs[NUM_PEERS];
+
+static struct GNUNET_CONFIGURATION_Handle *cfg_peers[NUM_PEERS];
+
+static struct GNUNET_STATISTICS_Handle *stats[NUM_PEERS];
+
+static char *cfg_peers_name[NUM_PEERS];
+
+static int finished[NUM_PEERS];
+
+static int ret;
+
+static int bidirect = GNUNET_NO;
+
+static size_t long_message_size;
+
+static struct GNUNET_TIME_Absolute start_short[NUM_PEERS];
+
+static struct GNUNET_TIME_Absolute start_long[NUM_PEERS];
+
+static struct GNUNET_TIME_Absolute timeout[NUM_PEERS];
+
+// static struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *my_tc;
+
+static char *communicator_name;
+
+static char *test_name;
+
+static struct GNUNET_STATISTICS_GetHandle *box_stats[NUM_PEERS];
+
+static struct GNUNET_STATISTICS_GetHandle *rekey_stats[NUM_PEERS];
+
+#define TEST_SECTION "test-setup"
+
+#define SHORT_MESSAGE_SIZE 128
+
+#define LONG_MESSAGE_SIZE 32000 /* FIXME */
+
+#define ALLOWED_PACKET_LOSS 91
+
+#define BURST_PACKETS 5000
+
+#define TOTAL_ITERATIONS 1
+
+#define PEER_A 0
+
+#define PEER_B 1
+
+static unsigned int iterations_left[NUM_PEERS];
+
+#define TIMEOUT_MULTIPLIER 5
+
+#define DEFAULT_DELAY \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS,200)
+
+#define SHORT_BURST_WINDOW \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,2)
+
+#define LONG_BURST_WINDOW \
+        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,2)
+
+enum TestPhase
+{
+  TP_INIT,
+  TP_BURST_SHORT,
+  TP_BURST_LONG,
+  TP_SIZE_CHECK
+};
+
+static unsigned int phase_short[NUM_PEERS];
+
+static unsigned int phase_long[NUM_PEERS];
+
+static unsigned int phase_size[NUM_PEERS];
+
+static long long unsigned int allowed_packet_loss_short;
+
+static long long unsigned int allowed_packet_loss_long;
+
+static long long unsigned int burst_packets_short;
+
+static long long unsigned int burst_packets_long;
+
+static long long unsigned int delay_long_value;
+
+static long long unsigned int delay_short_value;
+
+static struct GNUNET_TIME_Relative delay_short;
+
+static struct GNUNET_TIME_Relative delay_long;
+
+static size_t num_sent_short[NUM_PEERS];
+
+static size_t num_sent_long[NUM_PEERS];
+
+static size_t num_sent_size[NUM_PEERS];
+
+static uint32_t ack[NUM_PEERS];
+
+static enum TestPhase phase[NUM_PEERS];
+
+static size_t num_received_short[NUM_PEERS];
+
+static size_t num_received_long[NUM_PEERS];
+
+static size_t num_received_size[NUM_PEERS];
+
+static uint64_t avg_latency[NUM_PEERS];
+
+static void
+communicator_available_cb (
+  void *cls,
+  struct
+  GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h,
+  enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc,
+  char *address_prefix)
+{
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "Communicator available. (cc: %u, prefix: %s)\n",
+       cc,
+       address_prefix);
+}
+
+
+static void
+open_queue (void *cls)
+{
+  const char *address = cls;
+
+  if (NULL != tc_hs[PEER_A]->c_mq)
+  {
+    queue_est = GNUNET_YES;
+    GNUNET_TRANSPORT_TESTING_transport_communicator_open_queue (tc_hs[PEER_A],
+                                                                &peer_id[PEER_B]
+                                                                ,
+                                                                address);
+  }
+  else
+  {
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                  &open_queue,
+                                  (void *) address);
+  }
+}
+
+
+static void
+add_address_cb (
+  void *cls,
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h,
+  const char *address,
+  struct GNUNET_TIME_Relative expiration,
+  uint32_t aid,
+  enum GNUNET_NetworkType nt)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "New address. (addr: %s, expir: %s, ID: %" PRIu32 ", nt: %u\n",
+       address,
+       GNUNET_STRINGS_relative_time_to_string (expiration,
+                                               GNUNET_NO),
+       aid,
+       (int) nt);
+  // addresses[1] = GNUNET_strdup (address);
+  if ((0 == strcmp ((char*) cls, cfg_peers_name[PEER_B])) &&
+      (GNUNET_NO == queue_est))
+  {
+    open_queue ((void *) address);
+  }
+}
+
+
+/**
+ * @brief Callback that informs whether the requested queue will be
+ * established
+ *
+ * Implements #GNUNET_TRANSPORT_TESTING_QueueCreateReplyCallback.
+ *
+ * @param cls Closure - unused
+ * @param tc_h Communicator handle - unused
+ * @param will_try #GNUNET_YES if queue will be established
+ *                #GNUNET_NO if queue will not be established (bogous address)
+ */
+static void
+queue_create_reply_cb (
+  void *cls,
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h,
+  int will_try)
+{
+  (void) cls;
+  (void) tc_h;
+  if (GNUNET_YES == will_try)
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Queue will be established!\n");
+  else
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Queue won't be established (bougus address?)!\n");
+}
+
+
+static struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *
+handle_backchannel_cb (void *cls,
+                       struct GNUNET_MessageHeader *msg,
+                       struct GNUNET_PeerIdentity *pid)
+{
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
+
+  (void) tc_h;
+  (void) msg;
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Handling BC message...\n");
+  if (0 == memcmp (&peer_id[PEER_A], pid, sizeof (*pid)))
+    return tc_hs[PEER_A];
+  else
+    return tc_hs[PEER_B];
+}
+
+
+static char*
+make_payload (size_t payload_size)
+{
+  struct GNUNET_TIME_Absolute ts;
+  struct GNUNET_TIME_AbsoluteNBO ts_n;
+  char *payload = GNUNET_malloc (payload_size);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Making payload of size %lu\n", payload_size);
+  GNUNET_assert (payload_size >= 8); // So that out timestamp fits
+  ts = GNUNET_TIME_absolute_get ();
+  ts_n = GNUNET_TIME_absolute_hton (ts);
+  memset (payload, 'a', payload_size);
+  memcpy (payload, &ts_n, sizeof (struct GNUNET_TIME_AbsoluteNBO));
+  return payload;
+}
+
+
+static struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *
+get_tc_h (unsigned int peer_nr)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Got peer %u\n",
+       peer_nr);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Handle %p peer 0\n",
+       tc_hs[0]);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Handle %p peer 1\n",
+       tc_hs[1]);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Handle %p get\n",
+       tc_hs[peer_nr]);
+
+  return tc_hs[peer_nr];
+}
+
+
+static unsigned int
+get_peer_nr_from_tc (struct
+                     GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h)
+{
+  if (tc_h == get_tc_h (0))
+    return PEER_A;
+  else
+    return PEER_B;
+}
+
+
+static unsigned int
+get_peer_nr (void *cls, unsigned int get_the_other_one)
+{
+  if (0 == strcmp ((char*) cls, cfg_peers_name[0]))
+    return get_the_other_one ? PEER_B : PEER_A;
+  else
+    return get_the_other_one ? PEER_A : PEER_B;
+}
+
+
+static void
+process_statistics_box_done (void *cls, int success)
+{
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
+  unsigned int peer_nr;
+
+  peer_nr = get_peer_nr_from_tc (tc_h);
+
+  if (NULL != box_stats[peer_nr])
+    box_stats[peer_nr] = NULL;
+  if (NULL == rekey_stats[peer_nr])
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Finished\n");
+    GNUNET_SCHEDULER_shutdown ();
+  }
+}
+
+
+static void
+process_statistics_rekey_done (void *cls, int success)
+{
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
+  unsigned int peer_nr;
+
+  peer_nr = get_peer_nr_from_tc (tc_h);
+
+  if (NULL != rekey_stats[peer_nr])
+    rekey_stats[peer_nr] = NULL;
+  if (NULL == box_stats[peer_nr])
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Finished\n");
+    GNUNET_SCHEDULER_shutdown ();
+  }
+}
+
+
+static int
+process_statistics (void *cls,
+                    const char *subsystem,
+                    const char *name,
+                    uint64_t value,
+                    int is_persistent)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Statistic: Name %s and value %" PRIu64 "\n",
+       name,
+       value);
+  if ((0 == strcmp ("rekey", test_name)) && (0 == strcmp (
+                                               "# rekeying successful",
+                                               name)))
+  {
+    if (0 == value)
+    {
+      ret = 2;
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "No successful rekeying!\n");
+      GNUNET_SCHEDULER_shutdown ();
+    }
+    LOG (GNUNET_ERROR_TYPE_MESSAGE,
+         "Successful rekeys: %llu\n",
+         (unsigned long long) value);
+  }
+  if ((0 == strcmp ("backchannel", test_name)) &&
+      (0 == strcmp (
+         "# messages decrypted with BOX",
+         name))
+      && (9000 > value))
+  {
+    ret = 2;
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Not enough BOX messages! (want: %u, have %llu)\n",
+                9000, (unsigned long long) value);
+    GNUNET_SCHEDULER_shutdown ();
+  }
+  if ((0 == strcmp ("rekey", test_name)) &&
+      (0 == strcmp (
+         "# messages decrypted with BOX",
+         name))
+      && (6000 > value))
+  {
+    if (6000 > value)
+    {
+      ret = 2;
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Not enough BOX messages! (want: %u, have %llu)\n",
+                  6000, (unsigned long long) value);
+      GNUNET_SCHEDULER_shutdown ();
+    }
+    LOG (GNUNET_ERROR_TYPE_MESSAGE,
+         "Successful messages in BOX: %llu\n",
+         (unsigned long long) value);
+  }
+  return GNUNET_OK;
+}
+
+
+static void
+short_test (void *cls);
+
+static void
+short_test_cb (void *cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
+  unsigned int peer_nr;
+  char *payload;
+
+  peer_nr = get_peer_nr_from_tc (tc_h);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "short_test_cb %u/%u for peer %u and handle %p\n",
+       (unsigned int) num_sent_short[peer_nr],
+       (unsigned int) num_received_short[peer_nr],
+       peer_nr,
+       tc_h);
+  payload = make_payload (SHORT_MESSAGE_SIZE);
+  num_sent_short[peer_nr]++;
+  if (burst_packets_short == num_sent_short[peer_nr])
+    tc_h->cont = NULL;
+  else
+    tc_h->cont = short_test;
+  tc_h->cont_cls = cls;
+  GNUNET_TRANSPORT_TESTING_transport_communicator_send (tc_h,
+                                                        NULL,
+                                                        cls,
+                                                        payload,
+                                                        SHORT_MESSAGE_SIZE);
+  GNUNET_free (payload);
+  timeout[peer_nr] = GNUNET_TIME_relative_to_absolute (
+    GNUNET_TIME_relative_multiply (
+      GNUNET_TIME_UNIT_SECONDS,
+      TIMEOUT_MULTIPLIER));
+}
+
+
+static void
+short_test (void *cls)
+{
+  GNUNET_SCHEDULER_add_delayed (delay_short,
+                                &short_test_cb,
+                                cls);
+}
+
+
+static void
+size_test (void *cls)
+{
+  unsigned int peer_nr;
+  char *payload;
+  size_t max_size = 64000;
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
+
+  peer_nr = get_peer_nr_from_tc (tc_h);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "size_test_cb %u\n",
+       (unsigned int) num_sent_size[peer_nr]);
+  GNUNET_assert (TP_SIZE_CHECK == phase[peer_nr]);
+  if (LONG_MESSAGE_SIZE != long_message_size)
+    max_size = long_message_size;
+  if (ack[peer_nr] + 10 > max_size)
+    return; /* Leave some room for our protocol, so not 2^16 exactly */
+  ack[peer_nr] += 10;
+  payload = make_payload (ack[peer_nr]);
+  num_sent_size[peer_nr]++;
+  if (ack[peer_nr] >= max_size)
+    tc_h->cont = NULL;
+  else
+    tc_h->cont = size_test;
+  tc_h->cont_cls = cls;
+  GNUNET_TRANSPORT_TESTING_transport_communicator_send (tc_h,
+                                                        NULL,
+                                                        cls,
+                                                        payload,
+                                                        ack[peer_nr]);
+  GNUNET_free (payload);
+  timeout[peer_nr] = GNUNET_TIME_relative_to_absolute (
+    GNUNET_TIME_relative_multiply (
+      GNUNET_TIME_UNIT_SECONDS,
+      TIMEOUT_MULTIPLIER));
+}
+
+
+static void
+long_test (void *cls);
+
+static void
+long_test_cb (void *cls)
+{
+  unsigned int peer_nr;
+  char *payload;
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
+
+  peer_nr = get_peer_nr_from_tc (tc_h);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "long_test_cb %u/%u\n",
+       (unsigned int) num_sent_long[peer_nr],
+       (unsigned int) num_received_long[peer_nr]);
+  payload = make_payload (long_message_size);
+  num_sent_long[peer_nr]++;
+  if (burst_packets_long == num_sent_long[peer_nr])
+    tc_h->cont = NULL;
+  else
+    tc_h->cont = long_test;
+  tc_h->cont_cls = cls;
+  GNUNET_TRANSPORT_TESTING_transport_communicator_send (tc_h,
+                                                        NULL,
+                                                        cls,
+                                                        payload,
+                                                        long_message_size);
+  GNUNET_free (payload);
+  timeout[peer_nr] = GNUNET_TIME_relative_to_absolute (
+    GNUNET_TIME_relative_multiply (
+      GNUNET_TIME_UNIT_SECONDS,
+      TIMEOUT_MULTIPLIER));
+}
+
+
+static void
+long_test (void *cls)
+{
+  GNUNET_SCHEDULER_add_delayed (delay_long,
+                                &long_test_cb,
+                                cls);
+}
+
+
+static void
+choose_phase (struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h)
+{
+  unsigned int peer_nr;
+
+  peer_nr = get_peer_nr_from_tc (tc_h);
+
+  if (GNUNET_YES == phase_short[peer_nr])
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Choose phase short with peer %u and Handle %p\n",
+                peer_nr,
+                tc_h);
+    phase[peer_nr] =  TP_BURST_SHORT;
+    start_short[peer_nr] = GNUNET_TIME_absolute_get ();
+    short_test (tc_h);
+  }
+  else if (GNUNET_YES == phase_long[peer_nr])
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Choose phase long with peer %u\n",
+                peer_nr);
+    phase[peer_nr] =  TP_BURST_LONG;
+    start_long[peer_nr] = GNUNET_TIME_absolute_get ();
+    long_test (tc_h);
+  }
+  else if (GNUNET_YES == phase_size[peer_nr])
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Choose phase size\n");
+    phase[peer_nr] =  TP_SIZE_CHECK;
+    size_test (tc_h);
+  }
+  else
+  {
+    if ((0 == strcmp ("udp", communicator_name)) && ((0 == strcmp ("rekey",
+                                                                   test_name))
+                                                     || (0 == strcmp (
+                                                           "backchannel",
+                                                           test_name))) )
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG, "Getting statistics UDP...\n");
+      if (NULL != box_stats[peer_nr])
+        GNUNET_STATISTICS_get_cancel (box_stats[peer_nr]);
+      box_stats[peer_nr] = GNUNET_STATISTICS_get (stats[1],
+                                                  "communicator-udp",
+                                                  "# messages decrypted with BOX",
+                                                  process_statistics_box_done,
+                                                  &process_statistics,
+                                                  tc_h);
+      if (NULL != rekey_stats[peer_nr])
+        GNUNET_STATISTICS_get_cancel (rekey_stats[peer_nr]);
+      rekey_stats[peer_nr] = GNUNET_STATISTICS_get (stats[1],
+                                                    "communicator-udp",
+                                                    "# rekeying successful",
+                                                    process_statistics_rekey_done,
+                                                    &process_statistics,
+                                                    tc_h);
+    }
+    else if ((0 == strcmp ("tcp", communicator_name)) && (0 == strcmp ("rekey",
+                                                                        test_name)))
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG, "Getting statistics... TCP\n");
+      if (NULL != box_stats[peer_nr])
+        GNUNET_STATISTICS_get_cancel (box_stats[peer_nr]);
+      box_stats[peer_nr] = GNUNET_STATISTICS_get (stats[1],
+                                                  "communicator-tcp",
+                                                  //"# messages decrypted with BOX",
+                                                  NULL,
+                                                  process_statistics_box_done,
+                                                  &process_statistics,
+                                                  tc_h);
+      if (NULL != rekey_stats[peer_nr])
+        GNUNET_STATISTICS_get_cancel (rekey_stats[peer_nr]);
+      rekey_stats[peer_nr] = GNUNET_STATISTICS_get (stats[1],
+                                                    "communicator-tcp",
+                                                    "# rekeying successful",
+                                                    process_statistics_rekey_done,
+                                                    &process_statistics,
+                                                    tc_h);
+    }
+    else
+    {
+      if ((GNUNET_NO == bidirect) || (((PEER_A == peer_nr) &&
+                                       finished[PEER_B]) || ((PEER_B ==
+                                                              peer_nr) &&
+                                                             finished
+                                                             [PEER_A])))
+      {
+        LOG (GNUNET_ERROR_TYPE_DEBUG,
+             "Finished\n");
+        GNUNET_SCHEDULER_shutdown ();
+      }
+      finished[peer_nr] = GNUNET_YES;
+    }
+  }
+}
+
+
+static void
+finish_phase_long (unsigned int peer_nr)
+{
+  static struct GNUNET_TIME_Relative duration;
+
+  duration = GNUNET_TIME_absolute_get_duration (start_long[peer_nr]);
+  LOG (GNUNET_ERROR_TYPE_MESSAGE,
+       "Long size packet test  for peer %u done.\n",
+       peer_nr);
+  char *goodput = GNUNET_STRINGS_byte_size_fancy (
+    (long_message_size * num_received_long[peer_nr] * 1000 * 1000)
+    / duration.
+    rel_value_us);
+
+  LOG (GNUNET_ERROR_TYPE_MESSAGE,
+       "%lu/%lu packets in %llu us (%s/s) -- avg latency: %llu us\n",
+       (unsigned long) num_received_long[peer_nr],
+       (unsigned long) num_sent_long[peer_nr],
+       (unsigned long long) duration.rel_value_us,
+       goodput,
+       (unsigned long long) avg_latency[peer_nr]);
+  GNUNET_free (goodput);
+  ack[peer_nr] = 0;
+  // phase = TP_SIZE_CHECK;
+  // num_received = 0;
+  // num_sent_long = 0;
+  avg_latency[peer_nr] = 0;
+  // size_test (NULL);
+  phase_long[peer_nr] = GNUNET_NO;
+  choose_phase (get_tc_h (peer_nr));
+}
+
+
+static void
+finish_phase_short (unsigned int peer_nr)
+{
+  static struct GNUNET_TIME_Relative duration;
+
+  duration = GNUNET_TIME_absolute_get_duration (start_short[peer_nr]);
+  LOG (GNUNET_ERROR_TYPE_MESSAGE,
+       "Short size packet test for peer %u done.\n",
+       peer_nr);
+  char *goodput = GNUNET_STRINGS_byte_size_fancy (
+    (SHORT_MESSAGE_SIZE * num_received_short[peer_nr] * 1000 * 1000)
+    / duration.rel_value_us);
+  LOG (GNUNET_ERROR_TYPE_MESSAGE,
+       "%lu/%lu packets in %llu us (%s/s) -- avg latency: %llu us\n",
+       (unsigned long) num_received_short[peer_nr],
+       (unsigned long) num_sent_short[peer_nr],
+       (unsigned long long) duration.rel_value_us,
+       goodput,
+       (unsigned long long) avg_latency[peer_nr]);
+  GNUNET_free (goodput);
+  // start_long = GNUNET_TIME_absolute_get ();
+  // phase = TP_BURST_LONG;
+  // num_sent_short = 0;
+  avg_latency[peer_nr] = 0;
+  // num_received = 0;
+  phase_short[peer_nr] = GNUNET_NO;
+  choose_phase (get_tc_h (peer_nr));
+  // long_test (NULL);
+}
+
+
+static void
+latency_timeout (void *cls)
+{
+
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
+  unsigned int peer_nr;
+  size_t num_sent = 0;
+  size_t num_received = 0;
+
+  peer_nr = get_peer_nr_from_tc (tc_h);
+  to_task[peer_nr] = NULL;
+
+  switch (phase[peer_nr])
+  {
+  case TP_INIT:
+    GNUNET_assert (0);
+    break;
+  case TP_BURST_SHORT:
+    num_sent = num_sent_short[peer_nr];
+    num_received = num_received_short[peer_nr];
+    if ((num_sent_short[peer_nr] == burst_packets_short) &&
+        (num_received_short[peer_nr] >
+         burst_packets_short
+         / 100
+         *
+         allowed_packet_loss_short) )
+    {
+      finish_phase_short (peer_nr);
+      to_task[peer_nr] = GNUNET_SCHEDULER_add_at (timeout[peer_nr],
+                                                  &latency_timeout,
+                                                  cls);
+      return;
+    }
+    break;
+  case TP_BURST_LONG:
+    num_sent = num_sent_long[peer_nr];
+    num_received = num_received_long[peer_nr];
+    if ((num_sent_long[peer_nr] == burst_packets_long) &&
+        (num_received_long[peer_nr] >
+         burst_packets_long
+         / 100
+         *
+         allowed_packet_loss_long) )
+    {
+      finish_phase_long (peer_nr);
+      to_task[peer_nr] = GNUNET_SCHEDULER_add_at (timeout[peer_nr],
+                                                  &latency_timeout,
+                                                  cls);
+      return;
+    }
+    break;
+  case TP_SIZE_CHECK:
+    num_sent = num_sent_size[peer_nr];
+    num_received = num_received_size[peer_nr];
+    break;
+  }
+  if (GNUNET_TIME_absolute_get_remaining (timeout[peer_nr]).rel_value_us > 0)
+  {
+    to_task[peer_nr] = GNUNET_SCHEDULER_add_at (timeout[peer_nr],
+                                                &latency_timeout,
+                                                cls);
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_ERROR,
+       "Latency too high. Test failed. (Phase: %d. Sent: %lu, Received: %lu)\n",
+       phase[peer_nr], num_sent, num_received);
+  ret = 2;
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * @brief Handle opening of queue
+ *
+ * Issues sending of test data
+ *
+ * Implements #GNUNET_TRANSPORT_TESTING_AddQueueCallback
+ *
+ * @param cls Closure
+ * @param tc_h Communicator handle
+ * @param tc_queue Handle to newly opened queue
+ */
+static void
+add_queue_cb (void *cls,
+              struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h,
+              struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *
+              tc_queue,
+              size_t mtu)
+{
+
+  unsigned int peer_nr;
+
+  peer_nr = get_peer_nr (cls, GNUNET_NO);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Handle %p add %u %u\n",
+       tc_h,
+       peer_nr,
+       get_peer_nr_from_tc (tc_h));
+  if ((GNUNET_NO == bidirect) && (0 != strcmp ((char*) cls, cfg_peers_name[0])))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Queue available at receiving peer\n");
+    return; // TODO?
+  }
+  else if (TP_INIT != phase[peer_nr])
+    return;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Queue established, starting test...\n");
+  if (UINT16_MAX != mtu) /* Message header overhead */
+    long_message_size = mtu - sizeof(struct GNUNET_TRANSPORT_SendMessageTo)
+                        - sizeof(struct GNUNET_MessageHeader);
+  else
+    long_message_size = LONG_MESSAGE_SIZE;
+  timeout[peer_nr] = GNUNET_TIME_relative_to_absolute (
+    GNUNET_TIME_relative_multiply (
+      GNUNET_TIME_UNIT_SECONDS,
+      TIMEOUT_MULTIPLIER));
+  GNUNET_assert (NULL == to_task[peer_nr]);
+  to_task[peer_nr] = GNUNET_SCHEDULER_add_delayed (
+    GNUNET_TIME_relative_multiply (
+      GNUNET_TIME_UNIT_SECONDS,
+      TIMEOUT_MULTIPLIER),
+    &latency_timeout,
+    tc_h);
+  choose_phase (tc_h);
+}
+
+
+static void
+update_avg_latency (const char *payload, unsigned int peer_nr)
+{
+  struct GNUNET_TIME_AbsoluteNBO *ts_n;
+  struct GNUNET_TIME_Absolute ts;
+  struct GNUNET_TIME_Relative latency;
+  size_t num_received = 0;
+
+  ts_n = (struct GNUNET_TIME_AbsoluteNBO *) payload;
+  ts = GNUNET_TIME_absolute_ntoh (*ts_n);
+  latency = GNUNET_TIME_absolute_get_duration (ts);
+
+  switch (phase[peer_nr])
+  {
+  case TP_INIT:
+    GNUNET_assert (0);
+    break;
+  case TP_BURST_SHORT:
+    num_received = num_received_short[peer_nr];
+    break;
+  case TP_BURST_LONG:
+    num_received = num_received_long[peer_nr];
+    break;
+  case TP_SIZE_CHECK:
+    num_received = num_received_size[peer_nr];
+    break;
+  }
+  if (1 >= num_received)
+    avg_latency[peer_nr] = latency.rel_value_us;
+  else
+    avg_latency[peer_nr] = ((avg_latency[peer_nr] * (num_received - 1))
+                            + latency.rel_value_us)
+                           / num_received;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Latency of received packet by peer %u: %s with avg latency %" PRIu64
+       "\n",
+       peer_nr,
+       GNUNET_STRINGS_relative_time_to_string (latency,
+                                               GNUNET_YES),
+       avg_latency[peer_nr]);
+}
+
+
+static void
+load_phase_config ()
+{
+
+  phase_short[0] =  GNUNET_CONFIGURATION_get_value_yesno (cfg_peers[0],
+                                                          TEST_SECTION,
+                                                          "PHASE_SHORT");
+  if (GNUNET_SYSERR == phase_short[0])
+    phase_short[0] = GNUNET_YES;
+
+  phase_short[1] = phase_short[0];
+
+  phase_long[0] =  GNUNET_CONFIGURATION_get_value_yesno (cfg_peers[0],
+                                                         TEST_SECTION,
+                                                         "PHASE_LONG");
+
+  if (GNUNET_SYSERR == phase_long[0])
+    phase_long[0] = GNUNET_YES;
+
+  phase_long[1] = phase_long[0];
+
+  phase_size[0] =   GNUNET_CONFIGURATION_get_value_yesno (cfg_peers[0],
+                                                          TEST_SECTION,
+                                                          "PHASE_SIZE");
+
+  if (GNUNET_SYSERR == phase_size[0])
+    phase_size[0] = GNUNET_YES;
+
+  phase_size[1] = phase_size[0];
+}
+
+
+/**
+ * @brief Handle an incoming message
+ *
+ * Implements #GNUNET_TRANSPORT_TESTING_IncomingMessageCallback
+
+ * @param cls Closure
+ * @param tc_h Handle to the receiving communicator
+ * @param msg Received message
+ */
+static void
+incoming_message_cb (
+  void *cls,
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h,
+  const char *payload,
+  size_t payload_len)
+{
+  unsigned int peer_nr;
+
+
+  peer_nr = get_peer_nr (cls, GNUNET_YES);
+
+  if ((GNUNET_NO == bidirect) && (0 != strcmp ((char*) cls,
+                                               cfg_peers_name[NUM_PEERS - 1])))
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "unexpected receiver...\n");
+    return;
+  }
+  /* Reset timeout */
+  timeout[peer_nr] = GNUNET_TIME_relative_to_absolute (
+    GNUNET_TIME_relative_multiply (
+      GNUNET_TIME_UNIT_SECONDS,
+      TIMEOUT_MULTIPLIER));
+  switch (phase[peer_nr])
+  {
+  case TP_INIT:
+    GNUNET_break (0);
+    break;
+  case TP_BURST_SHORT:
+    {
+      GNUNET_assert (SHORT_MESSAGE_SIZE == payload_len);
+      num_received_short[peer_nr]++;
+
+      update_avg_latency (payload, peer_nr);
+      if ((num_sent_short[peer_nr] == burst_packets_short) &&
+          (num_received_short[peer_nr] ==
+           burst_packets_short))
+      {
+        finish_phase_short (peer_nr);
+      }
+      break;
+    }
+  case TP_BURST_LONG:
+    {
+      if (long_message_size != payload_len)
+      {
+        LOG (GNUNET_ERROR_TYPE_WARNING,
+             "Ignoring packet with wrong length (have: %lu, want: %lu)\n",
+             payload_len, long_message_size);
+        return;   // Ignore
+      }
+      num_received_long[peer_nr]++;
+
+      update_avg_latency (payload, peer_nr);
+      if ((num_sent_long[peer_nr] == burst_packets_long) &&
+          (num_received_long[peer_nr] >
+           burst_packets_long))
+      {
+        finish_phase_long (peer_nr);
+      }
+      break;
+    }
+  case TP_SIZE_CHECK:
+    {
+      size_t max_size = 64000;
+
+      GNUNET_assert (TP_SIZE_CHECK == phase[peer_nr]);
+      if (LONG_MESSAGE_SIZE != long_message_size)
+        max_size = long_message_size;
+      num_received_size[peer_nr]++;
+      update_avg_latency (payload, peer_nr);
+      if ((GNUNET_YES == phase_size[peer_nr]) && (num_received_size[peer_nr] >=
+                                                  (max_size) / 10) )
+      {
+        LOG (GNUNET_ERROR_TYPE_MESSAGE,
+             "Size packet test  for peer %u done.\n",
+             peer_nr);
+        LOG (GNUNET_ERROR_TYPE_MESSAGE,
+             "%lu/%lu packets -- avg latency: %llu us\n",
+             (unsigned long) num_received_size[peer_nr],
+             (unsigned long) num_sent_size[peer_nr],
+             (unsigned long long) avg_latency[peer_nr]);
+        iterations_left[peer_nr]--;
+        phase_size[peer_nr] = GNUNET_NO;
+        if (0 != iterations_left[peer_nr])
+        {
+          // start_short = GNUNET_TIME_absolute_get ();
+          // phase = TP_BURST_SHORT;
+          num_received_size[peer_nr] = 0;
+          num_sent_size[peer_nr] = 0;
+          avg_latency[peer_nr] = 0;
+          num_sent_short[peer_nr] = 0;
+          num_sent_long[peer_nr] = 0;
+          num_received_short[peer_nr] = 0;
+          num_received_long[peer_nr] = 0;
+          // short_test (NULL);
+          if (((PEER_A == peer_nr) && finished[PEER_B]) || ((PEER_B ==
+                                                             peer_nr) &&
+                                                            finished[PEER_A]))
+          {
+            load_phase_config ();
+          }
+        }
+        choose_phase (get_tc_h (peer_nr));
+      }
+      break;
+    }
+  }
+}
+
+
+static void
+do_shutdown (void *cls)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "shutting down test.\n");
+
+  for (unsigned int i = 0; i < NUM_PEERS; i++)
+  {
+    if (NULL != box_stats[i])
+    {
+      GNUNET_STATISTICS_get_cancel (box_stats[i]);
+      box_stats[i] = NULL;
+    }
+    if (NULL != rekey_stats[i])
+    {
+      GNUNET_STATISTICS_get_cancel (rekey_stats[i]);
+      rekey_stats[i] = NULL;
+    }
+    if (NULL != to_task[i])
+    {
+      GNUNET_SCHEDULER_cancel (to_task[i]);
+      to_task[i] = NULL;
+    }
+    GNUNET_STATISTICS_destroy (stats[i], GNUNET_YES);
+    GNUNET_TRANSPORT_TESTING_transport_communicator_service_stop (tc_hs[i]);
+  }
+}
+
+
+/**
+ * @brief Main function called by the scheduler
+ *
+ * @param cls Closure - Handle to confiation
+ */
+static void
+run (void *cls)
+{
+  ret = 0;
+  // num_received = 0;
+  // num_sent = 0;
+  for (unsigned int i = 0; i < NUM_PEERS; i++)
+  {
+    tc_hs[i] = GNUNET_TRANSPORT_TESTING_transport_communicator_service_start (
+      "transport",
+      communicator_binary,
+      cfg_peers_name[i],
+      &peer_id[i],
+      &communicator_available_cb,
+      &add_address_cb,
+      &queue_create_reply_cb,
+      &add_queue_cb,
+      &incoming_message_cb,
+      &handle_backchannel_cb,
+      cfg_peers_name[i]);   /* cls */
+
+    if ((0 == strcmp ("udp", communicator_name)) && ((0 == strcmp ("rekey",
+                                                                   test_name))
+                                                     ||
+                                                     (0 == strcmp (
+                                                        "backchannel",
+                                                        test_name))) )
+    {
+      stats[i] = GNUNET_STATISTICS_create ("communicator-udp",
+                                           cfg_peers[i]);
+    }
+    else if ((0 == strcmp ("tcp", communicator_name)) && (0 == strcmp ("rekey",
+                                                                        test_name)))
+    {
+      stats[i] = GNUNET_STATISTICS_create ("communicator-tcp",
+                                           cfg_peers[i]);
+    }
+    else if ((0 == strcmp ("bidirect", test_name)))
+    {
+      bidirect = GNUNET_YES;
+    }
+  }
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
+                                 NULL);
+}
+
+
+int
+main (int argc,
+      char *const *argv)
+{
+  struct GNUNET_CRYPTO_EddsaPrivateKey *private_key;
+  char *test_mode;
+  char *cfg_peer;
+
+  iterations_left[0] = TOTAL_ITERATIONS;
+  iterations_left[1] = TOTAL_ITERATIONS;
+  phase[0] = TP_INIT;
+  phase[1] = TP_INIT;
+  ret = 1;
+  test_name = GNUNET_STRINGS_get_suffix_from_binary_name (argv[0]);
+  communicator_name = strchr (test_name, '-');
+  communicator_name[0] = '\0';
+  communicator_name++;
+  test_mode = test_name;
+
+  GNUNET_asprintf (&communicator_binary,
+                   "gnunet-communicator-%s",
+                   communicator_name);
+
+  if (GNUNET_OK !=
+      GNUNET_log_setup ("test_communicator_basic",
+                        "DEBUG",
+                        NULL))
+  {
+    fprintf (stderr, "Unable to setup log\n");
+    GNUNET_break (0);
+    return 2;
+  }
+  for (unsigned int i = 0; i < NUM_PEERS; i++)
+  {
+    GNUNET_asprintf ((&cfg_peer),
+                     "test_communicator_%s_%s_peer%u.conf",
+                     communicator_name, test_mode, i + 1);
+    cfg_peers_name[i] = cfg_peer;
+    cfg_peers[i] = GNUNET_CONFIGURATION_create ();
+    if (GNUNET_YES ==
+        GNUNET_DISK_file_test (cfg_peers_name[i]))
+    {
+      if (GNUNET_SYSERR ==
+          GNUNET_CONFIGURATION_load (cfg_peers[i],
+                                     cfg_peers_name[i]))
+      {
+        fprintf (stderr,
+                 "Malformed configuration file `%s', exiting ...\n",
+                 cfg_peers_name[i]);
+        return 1;
+      }
+    }
+    else
+    {
+      if (GNUNET_SYSERR ==
+          GNUNET_CONFIGURATION_load (cfg_peers[i],
+                                     NULL))
+      {
+        fprintf (stderr,
+                 "Configuration file %s does not exist, exiting ...\n",
+                 cfg_peers_name[i]);
+        return 1;
+      }
+    }
+    private_key =
+      GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg_peers[i]);
+    if (NULL == private_key)
+    {
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           "Unable to get peer ID\n");
+      return 1;
+    }
+    GNUNET_CRYPTO_eddsa_key_get_public (private_key,
+                                        &peer_id[i].public_key);
+    GNUNET_free (private_key);
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "Identity of peer %u is %s\n",
+         i,
+         GNUNET_i2s_full (&peer_id[i]));
+  }
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_number (cfg_peers[0],
+                                             TEST_SECTION,
+                                             "ALLOWED_PACKET_LOSS_SHORT",
+                                             &allowed_packet_loss_short))
+    allowed_packet_loss_short = ALLOWED_PACKET_LOSS;
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_number (cfg_peers[0],
+                                             TEST_SECTION,
+                                             "ALLOWED_PACKET_LOSS_LONG",
+                                             &allowed_packet_loss_long))
+    allowed_packet_loss_long = ALLOWED_PACKET_LOSS;
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_number (cfg_peers[0],
+                                             TEST_SECTION,
+                                             "BURST_PACKETS_SHORT",
+                                             &burst_packets_short))
+    burst_packets_short = BURST_PACKETS;
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_number (cfg_peers[0],
+                                             TEST_SECTION,
+                                             "BURST_PACKETS_LONG",
+                                             &burst_packets_long))
+    burst_packets_long = BURST_PACKETS;
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_number (cfg_peers[0],
+                                             TEST_SECTION,
+                                             "DELAY_SHORT",
+                                             &delay_short_value))
+    delay_short = DEFAULT_DELAY;
+  else
+    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS,
+                                   delay_short_value);
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_number (cfg_peers[0],
+                                             TEST_SECTION,
+                                             "DELAY_SHORT",
+                                             &delay_long_value))
+    delay_long = DEFAULT_DELAY;
+  else
+    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS,
+                                   delay_long_value);
+  load_phase_config ();
+  LOG (GNUNET_ERROR_TYPE_MESSAGE, "Starting test...\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "argv[0]: %s\n",
+       argv[0]);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "test_name: %s\n",
+       test_name);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "communicator_name: %s\n",
+       communicator_name);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "communicator_binary: %s\n",
+       communicator_binary);
+  GNUNET_SCHEDULER_run (&run,
+                        NULL);
+  return ret;
+}
diff --git a/src/service/transport/test_communicator_quic_basic_peer1.conf b/src/service/transport/test_communicator_quic_basic_peer1.conf
new file mode 100644
index 000000000..d43752ecc
--- /dev/null
+++ b/src/service/transport/test_communicator_quic_basic_peer1.conf
@@ -0,0 +1,45 @@
+@INLINE@ test_transport_defaults.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-communicator-unix-1/
+
+[PEER]
+PRIVATE_KEY = $GNUNET_TMP/test-communicator-unix-1/private.key
+
+[transport-tcp]
+PORT = 52400
+
+[transport-udp]
+PORT = 52401
+
+[transport-quic]
+PORT = 52402
+
+[transport]
+#PORT = 60000
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-transport_test_1.sock
+
+[nat]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-1/nat.sock
+ENABLE_IPSCAN = YES
+
+[peerstore]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-1/peerstore.sock
+
+[statistics]
+PORT = 22461
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-statistics_test_1.sock
+
+[resolver]
+PORT = 62089
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_1.sock
+
+[communicator-udp]
+# PREFIX = valgrind --leak-check=full --track-origins=yes --log-file=/tmp/vg_com1
+BINDTO = 60002
+DISABLE_V6 = YES
+MAX_QUEUE_LENGTH=5000
+
+[communicator-quic]
+BINDTO = 60002
+DISABLE_V6 = YES
diff --git a/src/service/transport/test_communicator_quic_basic_peer2.conf b/src/service/transport/test_communicator_quic_basic_peer2.conf
new file mode 100644
index 000000000..4fabc8a86
--- /dev/null
+++ b/src/service/transport/test_communicator_quic_basic_peer2.conf
@@ -0,0 +1,45 @@
+@INLINE@ test_transport_defaults.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-gnunetd-plugin-transport/
+
+[PEER]
+PRIVATE_KEY = $GNUNET_TMP/test-communicator-unix-2/private.key
+
+[transport-tcp]
+PORT = 52400
+
+[transport-udp]
+PORT = 52402
+
+[transport-quic]
+PORT = 52403
+
+[transport]
+#PORT = 60001
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-transport_test_2.sock
+
+[nat]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-2/nat.sock
+
+
+[peerstore]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-2/peerstore.sock
+
+[statistics]
+PORT = 22462
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-statistics_test_2.sock
+
+[resolver]
+PORT = 62090
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_2.sock
+
+[communicator-udp]
+# PREFIX = valgrind --leak-check=full --track-origins=yes --log-file=/tmp/vg_com2
+BINDTO = 60003
+DISABLE_V6 = YES
+MAX_QUEUE_LENGTH=5000
+
+[communicator-quic]
+BINDTO = 60003
+DISABLE_V6 = YES
\ No newline at end of file
diff --git a/src/service/transport/test_communicator_tcp_basic_peer1.conf b/src/service/transport/test_communicator_tcp_basic_peer1.conf
new file mode 100644
index 000000000..dbc227ac6
--- /dev/null
+++ b/src/service/transport/test_communicator_tcp_basic_peer1.conf
@@ -0,0 +1,48 @@
+@INLINE@ test_transport_defaults.conf
+
+[test-setup]
+#PHASE_LONG=NO
+#PHASE_SIZE=NO
+#BURST_PACKETS_SHORT=1
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-communicator-unix-1/
+
+[PEER]
+PRIVATE_KEY = $GNUNET_TMP/test-communicator-unix-1/private.key
+
+[transport-tcp]
+PORT = 52400
+
+[transport-udp]
+PORT = 52401
+
+[transport]
+PORT = 60000
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-transport_test_1.sock
+
+[nat]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-1/nat.sock
+
+[peerstore]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-1/peerstore.sock
+
+[statistics]
+PORT = 22461
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-statistics_test_1.sock
+
+[communicator-unix]
+UNIXPATH = $GNUNET_RUNTIME_DIR/test_gnunet-communicator-unix_1.sock
+
+[communicator-tcp]
+#PREFIX = xterm -geometry 100x85 -T peer1 -e gdb --args
+#PREFIX = valgrind --leak-check=full --track-origins=yes
+BINDTO = 60002
+DISABLE_V6 = YES
+
+[communicator-udp]
+BINDTO = 60002
+
+[resolver]
+PORT = 62089
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_1.sock
diff --git a/src/service/transport/test_communicator_tcp_basic_peer2.conf b/src/service/transport/test_communicator_tcp_basic_peer2.conf
new file mode 100644
index 000000000..b73157f0d
--- /dev/null
+++ b/src/service/transport/test_communicator_tcp_basic_peer2.conf
@@ -0,0 +1,44 @@
+@INLINE@ test_transport_defaults.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-gnunetd-plugin-transport/
+
+[PEER]
+PRIVATE_KEY = $GNUNET_TMP/test-communicator-unix-2/private.key
+
+
+[transport-tcp]
+PORT = 52400
+
+[transport-udp]
+PORT = 52401
+
+[transport]
+PORT = 60001
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-transport_test_2.sock
+
+[nat]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-2/nat.sock
+
+[peerstore]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-2/peerstore.sock
+
+[statistics]
+PORT = 22462
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-statistics_test_2.sock
+
+[communicator-unix]
+UNIXPATH = $GNUNET_RUNTIME_DIR/test_gnunet-communicator-unix_2.sock
+
+[communicator-tcp]
+#PREFIX = xterm -geometry 100x85 -T peer2 -e gdb --args
+#PREFIX = valgrind --leak-check=full --track-origins=yes 
+BINDTO = 60003
+DISABLE_V6 = YES
+
+[communicator-udp]
+BINDTO = 60003
+
+[resolver]
+PORT = 62090
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_2.sock
diff --git a/src/service/transport/test_communicator_tcp_bidirect_peer1.conf b/src/service/transport/test_communicator_tcp_bidirect_peer1.conf
new file mode 100644
index 000000000..dbc227ac6
--- /dev/null
+++ b/src/service/transport/test_communicator_tcp_bidirect_peer1.conf
@@ -0,0 +1,48 @@
+@INLINE@ test_transport_defaults.conf
+
+[test-setup]
+#PHASE_LONG=NO
+#PHASE_SIZE=NO
+#BURST_PACKETS_SHORT=1
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-communicator-unix-1/
+
+[PEER]
+PRIVATE_KEY = $GNUNET_TMP/test-communicator-unix-1/private.key
+
+[transport-tcp]
+PORT = 52400
+
+[transport-udp]
+PORT = 52401
+
+[transport]
+PORT = 60000
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-transport_test_1.sock
+
+[nat]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-1/nat.sock
+
+[peerstore]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-1/peerstore.sock
+
+[statistics]
+PORT = 22461
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-statistics_test_1.sock
+
+[communicator-unix]
+UNIXPATH = $GNUNET_RUNTIME_DIR/test_gnunet-communicator-unix_1.sock
+
+[communicator-tcp]
+#PREFIX = xterm -geometry 100x85 -T peer1 -e gdb --args
+#PREFIX = valgrind --leak-check=full --track-origins=yes
+BINDTO = 60002
+DISABLE_V6 = YES
+
+[communicator-udp]
+BINDTO = 60002
+
+[resolver]
+PORT = 62089
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_1.sock
diff --git a/src/service/transport/test_communicator_tcp_bidirect_peer2.conf b/src/service/transport/test_communicator_tcp_bidirect_peer2.conf
new file mode 100644
index 000000000..b73157f0d
--- /dev/null
+++ b/src/service/transport/test_communicator_tcp_bidirect_peer2.conf
@@ -0,0 +1,44 @@
+@INLINE@ test_transport_defaults.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-gnunetd-plugin-transport/
+
+[PEER]
+PRIVATE_KEY = $GNUNET_TMP/test-communicator-unix-2/private.key
+
+
+[transport-tcp]
+PORT = 52400
+
+[transport-udp]
+PORT = 52401
+
+[transport]
+PORT = 60001
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-transport_test_2.sock
+
+[nat]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-2/nat.sock
+
+[peerstore]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-2/peerstore.sock
+
+[statistics]
+PORT = 22462
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-statistics_test_2.sock
+
+[communicator-unix]
+UNIXPATH = $GNUNET_RUNTIME_DIR/test_gnunet-communicator-unix_2.sock
+
+[communicator-tcp]
+#PREFIX = xterm -geometry 100x85 -T peer2 -e gdb --args
+#PREFIX = valgrind --leak-check=full --track-origins=yes 
+BINDTO = 60003
+DISABLE_V6 = YES
+
+[communicator-udp]
+BINDTO = 60003
+
+[resolver]
+PORT = 62090
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_2.sock
diff --git a/src/service/transport/test_communicator_tcp_rekey_peer1.conf b/src/service/transport/test_communicator_tcp_rekey_peer1.conf
new file mode 100644
index 000000000..82fbf353a
--- /dev/null
+++ b/src/service/transport/test_communicator_tcp_rekey_peer1.conf
@@ -0,0 +1,45 @@
+@INLINE@ test_transport_defaults.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-communicator-unix-1/
+
+[PEER]
+PRIVATE_KEY = $GNUNET_TMP/test-communicator-unix-1/private.key
+
+[transport-tcp]
+PORT = 52400
+
+[transport-udp]
+PORT = 52401
+
+[transport]
+PORT = 60000
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-transport_test_1.sock
+
+[nat]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-1/nat.sock
+ENABLE_IPSCAN = YES
+
+[peerstore]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-1/peerstore.sock
+
+[statistics]
+PORT = 22461
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-statistics_test_1.sock
+
+[resolver]
+PORT = 62089
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_1.sock
+
+[communicator-unix]
+UNIXPATH = $GNUNET_RUNTIME_DIR/test_gnunet-communicator-unix_1.sock
+
+[communicator-tcp]
+#PREFIX = xterm -geometry 100x85 -T peer1 -e gdb --args
+#PREFIX = valgrind --leak-check=full --track-origins=yes
+BINDTO = 60002
+DISABLE_V6 = YES
+REKEY_INTERVAL = 100ms
+
+[communicator-udp]
+BINDTO = 60002
diff --git a/src/service/transport/test_communicator_tcp_rekey_peer2.conf b/src/service/transport/test_communicator_tcp_rekey_peer2.conf
new file mode 100644
index 000000000..086a996ae
--- /dev/null
+++ b/src/service/transport/test_communicator_tcp_rekey_peer2.conf
@@ -0,0 +1,45 @@
+@INLINE@ test_transport_defaults.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-gnunetd-plugin-transport/
+
+[PEER]
+PRIVATE_KEY = $GNUNET_TMP/test-communicator-unix-2/private.key
+
+
+[transport-tcp]
+PORT = 52400
+
+[transport-udp]
+PORT = 52401
+
+[transport]
+PORT = 60001
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-transport_test_2.sock
+
+[nat]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-2/nat.sock
+
+[peerstore]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-2/peerstore.sock
+
+[statistics]
+PORT = 22462
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-statistics_test_2.sock
+
+[resolver]
+PORT = 62090
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_2.sock
+
+[communicator-unix]
+UNIXPATH = $GNUNET_RUNTIME_DIR/test_gnunet-communicator-unix_2.sock
+
+[communicator-tcp]
+#PREFIX = xterm -geometry 100x85 -T peer2 -e gdb --args
+#PREFIX = valgrind --leak-check=full --track-origins=yes
+BINDTO = 60003
+DISABLE_V6 = YES
+REKEY_INTERVAL = 100ms
+
+[communicator-udp]
+BINDTO = 60003
diff --git a/src/service/transport/test_communicator_udp_backchannel_peer1.conf b/src/service/transport/test_communicator_udp_backchannel_peer1.conf
new file mode 100644
index 000000000..65f33bd6b
--- /dev/null
+++ b/src/service/transport/test_communicator_udp_backchannel_peer1.conf
@@ -0,0 +1,48 @@
+@INLINE@ test_transport_defaults.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-communicator-unix-1/
+
+[PEER]
+PRIVATE_KEY = $GNUNET_TMP/test-communicator-unix-1/private.key
+
+[transport-tcp]
+PORT = 52400
+
+[transport-udp]
+PORT = 52401
+
+[transport]
+PORT = 60000
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-transport_test_1.sock
+
+[nat]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-1/nat.sock
+ENABLE_IPSCAN = YES
+
+[peerstore]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-1/peerstore.sock
+
+[statistics]
+PORT = 22461
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-statistics_test_1.sock
+
+[resolver]
+PORT = 62089
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_1.sock
+
+[communicator-unix]
+UNIXPATH = $GNUNET_RUNTIME_DIR/test_gnunet-communicator-unix_1.sock
+
+[communicator-tcp]
+BINDTO = 60002
+DISABLE_V6 = YES
+
+[communicator-udp]
+# PREFIX = valgrind --leak-check=full --track-origins=yes --log-file=/tmp/vg_comm1
+BINDTO = 60002
+DISABLE_V6 = YES
+MAX_QUEUE_LENGTH=5000
+
+[communicator-test]
+BACKCHANNEL_ENABLED = YES
diff --git a/src/service/transport/test_communicator_udp_backchannel_peer2.conf b/src/service/transport/test_communicator_udp_backchannel_peer2.conf
new file mode 100644
index 000000000..9875af724
--- /dev/null
+++ b/src/service/transport/test_communicator_udp_backchannel_peer2.conf
@@ -0,0 +1,48 @@
+@INLINE@ test_transport_defaults.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-gnunetd-plugin-transport/
+
+[PEER]
+PRIVATE_KEY = $GNUNET_TMP/test-communicator-unix-2/private.key
+
+
+[transport-tcp]
+PORT = 52400
+
+[transport-udp]
+PORT = 52401
+
+[transport]
+PORT = 60001
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-transport_test_2.sock
+
+[nat]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-2/nat.sock
+
+[peerstore]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-2/peerstore.sock
+
+[statistics]
+PORT = 22462
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-statistics_test_2.sock
+
+[resolver]
+PORT = 62090
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_2.sock
+
+[communicator-unix]
+UNIXPATH = $GNUNET_RUNTIME_DIR/test_gnunet-communicator-unix_2.sock
+
+[communicator-tcp]
+BINDTO = 60003
+DISABLE_V6 = YES
+
+[communicator-udp]
+# PREFIX = valgrind --leak-check=full --track-origins=yes --log-file=/tmp/vg_comm2
+BINDTO = 60003
+DISABLE_V6 = YES
+MAX_QUEUE_LENGTH=5000
+
+[communicator-test]
+BACKCHANNEL_ENABLED = YES
diff --git a/src/service/transport/test_communicator_udp_basic_peer1.conf b/src/service/transport/test_communicator_udp_basic_peer1.conf
new file mode 100644
index 000000000..83c599ae5
--- /dev/null
+++ b/src/service/transport/test_communicator_udp_basic_peer1.conf
@@ -0,0 +1,40 @@
+@INLINE@ test_transport_defaults.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-communicator-unix-1/
+
+[PEER]
+PRIVATE_KEY = $GNUNET_TMP/test-communicator-unix-1/private.key
+
+[transport-tcp]
+PORT = 52400
+
+[transport-udp]
+PORT = 52401
+
+[transport]
+#PORT = 60000
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-transport_test_1.sock
+
+[nat]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-1/nat.sock
+ENABLE_IPSCAN = YES
+
+[peerstore]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-1/peerstore.sock
+
+[statistics]
+PORT = 22461
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-statistics_test_1.sock
+
+[resolver]
+PORT = 62089
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_1.sock
+
+[communicator-udp]
+# PREFIX = valgrind --leak-check=full --track-origins=yes --log-file=/tmp/vg_com1
+#PREFIX = valgrind --tool=callgrind
+BINDTO = 60002
+DISABLE_V6 = YES
+MAX_QUEUE_LENGTH=5000
+
diff --git a/src/service/transport/test_communicator_udp_basic_peer2.conf b/src/service/transport/test_communicator_udp_basic_peer2.conf
new file mode 100644
index 000000000..781bfa7da
--- /dev/null
+++ b/src/service/transport/test_communicator_udp_basic_peer2.conf
@@ -0,0 +1,39 @@
+@INLINE@ test_transport_defaults.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-gnunetd-plugin-transport/
+
+[PEER]
+PRIVATE_KEY = $GNUNET_TMP/test-communicator-unix-2/private.key
+
+
+[transport-tcp]
+PORT = 52400
+
+[transport-udp]
+PORT = 52402
+
+[transport]
+#PORT = 60001
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-transport_test_2.sock
+
+[nat]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-2/nat.sock
+
+
+[peerstore]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-2/peerstore.sock
+
+[statistics]
+PORT = 22462
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-statistics_test_2.sock
+
+[resolver]
+PORT = 62090
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_2.sock
+
+[communicator-udp]
+# PREFIX = valgrind --leak-check=full --track-origins=yes --log-file=/tmp/vg_com2
+BINDTO = 60003
+DISABLE_V6 = YES
+MAX_QUEUE_LENGTH=5000
diff --git a/src/service/transport/test_communicator_udp_rekey_peer1.conf b/src/service/transport/test_communicator_udp_rekey_peer1.conf
new file mode 100644
index 000000000..305dd3b84
--- /dev/null
+++ b/src/service/transport/test_communicator_udp_rekey_peer1.conf
@@ -0,0 +1,53 @@
+@INLINE@ test_transport_defaults.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-communicator-unix-1/
+
+[PEER]
+PRIVATE_KEY = $GNUNET_TMP/test-communicator-unix-1/private.key
+
+[transport-tcp]
+PORT = 52400
+
+[transport-udp]
+PORT = 52401
+
+[transport]
+PORT = 60000
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-transport_test_1.sock
+
+[nat]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-1/nat.sock
+ENABLE_IPSCAN = YES
+
+[peerstore]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-1/peerstore.sock
+
+[statistics]
+PORT = 22461
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-statistics_test_1.sock
+
+[resolver]
+PORT = 62089
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_1.sock
+
+[communicator-unix]
+UNIXPATH = $GNUNET_RUNTIME_DIR/test_gnunet-communicator-unix_1.sock
+
+[communicator-tcp]
+BINDTO = 60002
+DISABLE_V6 = YES
+REKEY_INTERVAL = 100ms
+
+[communicator-udp]
+#PREFIX = xterm -geometry 100x85 -T peer1 -e gdb --args
+#PREFIX = valgrind --leak-check=full --track-origins=yes
+#PREFIX = valgrind --tool=callgrind
+BINDTO = 60002
+DISABLE_V6 = YES
+MAX_QUEUE_LENGTH=5000
+REKEY_INTERVAL = 100ms
+REKEY_MAX_BYTES=500KiB
+
+[communicator-test]
+BACKCHANNEL_ENABLED = YES
diff --git a/src/service/transport/test_communicator_udp_rekey_peer2.conf b/src/service/transport/test_communicator_udp_rekey_peer2.conf
new file mode 100644
index 000000000..9bce572aa
--- /dev/null
+++ b/src/service/transport/test_communicator_udp_rekey_peer2.conf
@@ -0,0 +1,52 @@
+@INLINE@ test_transport_defaults.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-gnunetd-plugin-transport/
+
+[PEER]
+PRIVATE_KEY = $GNUNET_TMP/test-communicator-unix-2/private.key
+
+
+[transport-tcp]
+PORT = 52400
+
+[transport-udp]
+PORT = 52401
+
+[transport]
+PORT = 60001
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-transport_test_2.sock
+
+[nat]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-2/nat.sock
+
+[peerstore]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-2/peerstore.sock
+
+[statistics]
+PORT = 22462
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-statistics_test_2.sock
+
+[resolver]
+PORT = 62090
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_2.sock
+
+[communicator-unix]
+UNIXPATH = $GNUNET_RUNTIME_DIR/test_gnunet-communicator-unix_2.sock
+
+[communicator-tcp]
+BINDTO = 60003
+DISABLE_V6 = YES
+REKEY_INTERVAL = 100ms
+
+[communicator-udp]
+#PREFIX = xterm -geometry 100x85 -T peer1 -e gdb --args
+#PREFIX = valgrind --leak-check=full --track-origins=yes
+BINDTO = 60003
+DISABLE_V6 = YES
+MAX_QUEUE_LENGTH=5000
+REKEY_INTERVAL = 100ms
+REKEY_MAX_BYTES=500KiB
+
+[communicator-test]
+BACKCHANNEL_ENABLED = YES
diff --git a/src/service/transport/test_communicator_unix_basic_peer1.conf b/src/service/transport/test_communicator_unix_basic_peer1.conf
new file mode 100644
index 000000000..13ba2d16b
--- /dev/null
+++ b/src/service/transport/test_communicator_unix_basic_peer1.conf
@@ -0,0 +1,43 @@
+@INLINE@ test_transport_defaults.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-communicator-unix-1/
+
+[PEER]
+PRIVATE_KEY = $GNUNET_TMP/test-communicator-unix-1/private.key
+
+[transport-tcp]
+PORT = 52400
+
+[transport-udp]
+PORT = 52401
+
+[transport]
+PORT = 60000
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-transport_test_1.sock
+
+[nat]
+UNIXPATH = $GNUNET_TMP/communicator-unix-1/nat.sock
+ENABLE_IPSCAN = YES
+
+[peerstore]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-1/peerstore.sock
+
+[statistics]
+PORT = 22461
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-statistics_test_1.sock
+
+[resolver]
+PORT = 62089
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_1.sock
+
+[communicator-unix]
+#PREFIX = xterm -geometry 100x85 -T peer1 -e gdb --args
+#PREFIX = valgrind --leak-check=full --track-origins=yes
+UNIXPATH = $GNUNET_RUNTIME_DIR/communicator-unix-1.sock
+
+[communicator-tcp]
+BINDTO = 60002
+
+[communicator-udp]
+BINDTO = 60002
diff --git a/src/service/transport/test_communicator_unix_basic_peer2.conf b/src/service/transport/test_communicator_unix_basic_peer2.conf
new file mode 100644
index 000000000..727e844a7
--- /dev/null
+++ b/src/service/transport/test_communicator_unix_basic_peer2.conf
@@ -0,0 +1,43 @@
+@INLINE@ test_transport_defaults.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-gnunetd-plugin-transport/
+
+[PEER]
+PRIVATE_KEY = $GNUNET_TMP/test-communicator-unix-2/private.key
+
+
+[transport-tcp]
+PORT = 52400
+
+[transport-udp]
+PORT = 52401
+
+[transport]
+PORT = 60001
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-transport_test_2.sock
+
+[nat]
+UNIXPATH = $GNUNET_TMP/communicator-unix-2/nat.sock
+
+[peerstore]
+UNIXPATH = $GNUNET_TMP/test-communicator-unix-2/peerstore.sock
+
+[statistics]
+PORT = 22462
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-statistics_test_2.sock
+
+[resolver]
+PORT = 62090
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_2.sock
+
+[communicator-unix]
+#PREFIX = xterm -geometry 100x85 -T peer2 -e gdb --args
+#PREFIX = valgrind --leak-check=full --track-origins=yes
+UNIXPATH = $GNUNET_RUNTIME_DIR/communicator-unix-2.sock
+
+[communicator-tcp]
+BINDTO = 60003
+
+[communicator-udp]
+BINDTO = 60003
diff --git a/src/service/transport/test_delay b/src/service/transport/test_delay
new file mode 100755
index 000000000..5f82b65fb
--- /dev/null
+++ b/src/service/transport/test_delay
@@ -0,0 +1,19 @@
+#!/bin/sh
+
+TEMP=$(getopt t: "$*")
+
+if [ $? != 0 ] ; then
+  exit 1
+fi
+
+eval set -- "$TEMP"
+
+while true ; do
+  case "$1" in
+    (-t) sleep "$2" ; shift 2 ;;
+    (--) shift ; break ;;
+    (*) echo "Error parsing getopt output" ; exit 1 ;;
+  esac
+done
+echo "exec $@"
+exec "$@"
diff --git a/src/service/transport/test_plugin_hostkey b/src/service/transport/test_plugin_hostkey
new file mode 100644
index 000000000..e7b1ad012
--- /dev/null
+++ b/src/service/transport/test_plugin_hostkey
diff --git a/src/service/transport/test_plugin_hostkey.ecc b/src/service/transport/test_plugin_hostkey.ecc
new file mode 100644
index 000000000..18641b798
--- /dev/null
+++ b/src/service/transport/test_plugin_hostkey.ecc
@@ -0,0 +1 @@
+‚”ˆÖ’ÛËy¢/HÒc
ȃ§¿±;¼»f?¶@…~áJ
\ No newline at end of file
diff --git a/src/service/transport/test_tng_defaults.conf b/src/service/transport/test_tng_defaults.conf
new file mode 100644
index 000000000..81dbb5bd7
--- /dev/null
+++ b/src/service/transport/test_tng_defaults.conf
@@ -0,0 +1,14 @@
+@INLINE@ ../../../contrib/conf/gnunet/no_forcestart.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-tng/
+
+[transport]
+# PREFIX = valgrind 
+
+[nat]
+DISABLEV6 = NO
+RETURN_LOCAL_ADDRESSES = YES
+BINDTO = 127.0.0.1
+INTERNAL_ADDRESS = 127.0.0.1
+EXTERNAL_ADDRESS = 127.0.0.1
diff --git a/src/service/transport/test_transport_address_switch.c b/src/service/transport/test_transport_address_switch.c
new file mode 100644
index 000000000..ce5117bd1
--- /dev/null
+++ b/src/service/transport/test_transport_address_switch.c
@@ -0,0 +1,433 @@
+/*
+   This file is part of GNUnet.
+   Copyright (C) 2009, 2010, 2011, 2016 GNUnet e.V.
+
+   GNUnet is free software: you can redistribute it and/or modify it
+   under the terms of the GNU Affero General Public License as published
+   by the Free Software Foundation, either version 3 of the License,
+   or (at your option) any later version.
+
+   GNUnet is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Affero General Public License for more details.
+
+   You should have received a copy of the GNU Affero General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+/**
+ * @file transport/test_transport_address_switch.c
+ * @brief base test case for transport implementations
+ *
+ * This test case tests if peers can successfully switch addresses when
+ * connected for plugins supporting multiple addresses by monitoring transport's
+ * statistic values.
+ *
+ * This test starts 2 peers and connects them. When connected test messages
+ * are transmitted from peer 2 to peer 1. The test monitors transport's
+ * statistics values for information about address switch attempts.
+ *
+ * The test passes with success if one of the peers could successfully switch
+ * addresses in connected state and a test message was successfully transmitted
+ * after this switch.
+ *
+ * Since it is not possible to trigger an address switch from outside,
+ * the test returns "77" (skipped) when no address switching attempt
+ * takes place. It fails if an address switch attempt fails.
+ *
+ * NOTE: The test seems largely useless right now, as we simply NEVER
+ * switch addresses under the test conditions.  However, it may be a
+ * good starting point for a future test.  For now, it always times
+ * out and returns "77" (skipped), so we set the timeout suitably low.
+ */
+#include "platform.h"
+#include "gnunet_transport_service.h"
+#include "gnunet_ats_service.h"
+#include "transport-testing.h"
+
+
+/**
+ * Testcase timeout (set aggressively as we know this test doesn't work right now)
+ */
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
+
+
+static struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc;
+
+static struct GNUNET_SCHEDULER_Task *measure_task;
+
+
+/**
+ * Statistics we track per peer.
+ */
+struct PeerStats
+{
+  struct GNUNET_STATISTICS_Handle *stat;
+
+  unsigned int addresses_avail;
+
+  unsigned int switch_attempts;
+
+  unsigned int switch_success;
+
+  unsigned int switch_fail;
+};
+
+static struct PeerStats stats[2];
+
+/* Amount of data transferred since last switch attempt */
+static unsigned long long bytes_sent_after_switch;
+
+static unsigned long long bytes_recv_after_switch;
+
+
+static int
+stat_start_attempt_cb (void *cls,
+                       const char *subsystem,
+                       const char *name,
+                       uint64_t value,
+                       int is_persistent)
+{
+  struct PeerStats *stat = cls;
+
+  stat->switch_attempts++;
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Switch attempted (%p)", stat);
+  bytes_recv_after_switch = 0;
+  bytes_sent_after_switch = 0;
+
+  return GNUNET_OK;
+}
+
+
+static int
+stat_success_attempt_cb (void *cls,
+                         const char *subsystem,
+                         const char *name,
+                         uint64_t value,
+                         int is_persistent)
+{
+  struct PeerStats *stat = cls;
+
+  stat->switch_success++;
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Switch succeeded (%p)", stat);
+  return GNUNET_OK;
+}
+
+
+static int
+stat_fail_attempt_cb (void *cls,
+                      const char *subsystem,
+                      const char *name,
+                      uint64_t value,
+                      int is_persistent)
+{
+  struct PeerStats *stat = cls;
+
+  if (value == 0)
+    return GNUNET_OK;
+
+  stat->switch_fail++;
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Switch failed (%p)", stat);
+  return GNUNET_OK;
+}
+
+
+static int
+stat_addresses_available (void *cls,
+                          const char *subsystem,
+                          const char *name,
+                          uint64_t value,
+                          int is_persistent)
+{
+  struct PeerStats *stat = cls;
+
+  stat->addresses_avail++;
+  return GNUNET_OK;
+}
+
+
+/**
+ * List of statistics entries we care about.
+ */
+static struct WatchEntry
+{
+  /**
+   * Name of the statistic we watch.
+   */
+  const char *stat_name;
+
+  /**
+   * Handler to register;
+   */
+  GNUNET_STATISTICS_Iterator stat_handler;
+} watches[] =
+{ { "# Attempts to switch addresses", &stat_start_attempt_cb },
+  { "# Successful attempts to switch addresses", &stat_success_attempt_cb },
+  { "# Failed attempts to switch addresses (failed to send CONNECT CONT)",
+    &stat_fail_attempt_cb },
+  { "# Failed attempts to switch addresses (failed to send CONNECT)",
+    &stat_fail_attempt_cb },
+  { "# Failed attempts to switch addresses (no response)",
+    &stat_fail_attempt_cb },
+  { "# transport addresses", &stat_addresses_available },
+  { NULL, NULL } };
+
+
+static void
+custom_shutdown (void *cls)
+{
+  int result;
+
+  if (NULL != measure_task)
+  {
+    GNUNET_SCHEDULER_cancel (measure_task);
+    measure_task = NULL;
+  }
+  if (0 == stats[0].switch_attempts + stats[1].switch_attempts)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Test did not work, as peers didn't switch (flawed testcase)!\n");
+    ccc->global_ret = 77;
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Fail (timeout)! No transmission after switch! Stopping peers\n");
+    ccc->global_ret = 77;   /* GNUNET_SYSERR; */
+  }
+
+  /* stop statistics */
+  for (unsigned int i = 0; i < 2; i++)
+  {
+    if (NULL != stats[i].stat)
+    {
+      for (unsigned int j = 0; NULL != watches[j].stat_name; j++)
+        GNUNET_assert (GNUNET_OK ==
+                       GNUNET_STATISTICS_watch_cancel (stats[i].stat,
+                                                       "transport",
+                                                       watches[j].stat_name,
+                                                       watches[j].stat_handler,
+                                                       &stats[i]));
+      GNUNET_STATISTICS_destroy (stats[i].stat, GNUNET_NO);
+      stats[i].stat = NULL;
+    }
+  }
+
+  result = 0;
+  fprintf (stderr, "\n");
+  if (stats[0].switch_attempts > 0)
+  {
+    fprintf (
+      stderr,
+      "Peer 1 tried %u times to switch and succeeded %u times, failed %u times\n",
+      stats[0].switch_attempts,
+      stats[0].switch_success,
+      stats[0].switch_fail);
+    if (stats[0].switch_success != stats[0].switch_attempts)
+    {
+      GNUNET_break (0);
+      result++;
+    }
+  }
+  else if (stats[0].addresses_avail > 1)
+  {
+    fprintf (stderr,
+             "Peer 1 had %u addresses available, but did not try to switch\n",
+             stats[0].addresses_avail);
+  }
+  if (stats[1].switch_attempts > 0)
+  {
+    fprintf (
+      stderr,
+      "Peer 2 tried %u times to switch and succeeded %u times, failed %u times\n",
+      stats[1].switch_attempts,
+      stats[1].switch_success,
+      stats[1].switch_fail);
+    if (stats[1].switch_success != stats[1].switch_attempts)
+    {
+      GNUNET_break (0);
+      result++;
+    }
+  }
+  else if (stats[1].addresses_avail > 1)
+  {
+    fprintf (stderr,
+             "Peer 2 had %u addresses available, but did not try to switch\n",
+             stats[1].addresses_avail);
+  }
+
+  if (((stats[0].switch_attempts > 0) || (stats[1].switch_attempts > 0)) &&
+      (bytes_sent_after_switch == 0))
+  {
+    fprintf (stderr, "No data sent after switching!\n");
+    GNUNET_break (0);
+    result++;
+  }
+  if (((stats[0].switch_attempts > 0) || (stats[1].switch_attempts > 0)) &&
+      (bytes_recv_after_switch == 0))
+  {
+    fprintf (stderr, "No data received after switching!\n");
+    GNUNET_break (0);
+    result++;
+  }
+#if 0
+  /* This test is not really expected to pass right now... */
+  if (0 != result)
+    ccc->global_ret = GNUNET_SYSERR;
+#endif
+}
+
+
+static void
+notify_receive (void *cls,
+                struct GNUNET_TRANSPORT_TESTING_PeerContext *receiver,
+                const struct GNUNET_PeerIdentity *sender,
+                const struct GNUNET_TRANSPORT_TESTING_TestMessage *hdr)
+{
+  if (GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE != ntohs (hdr->header.type))
+    return;
+
+  {
+    char *ps = GNUNET_strdup (GNUNET_i2s (&receiver->id));
+
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Peer %u (`%s') got message %u of size %u from peer (`%s')\n",
+                receiver->no,
+                ps,
+                (uint32_t) ntohl (hdr->num),
+                ntohs (hdr->header.size),
+                GNUNET_i2s (sender));
+    GNUNET_free (ps);
+  }
+  if (((stats[0].switch_attempts >= 1) || (stats[1].switch_attempts >= 1)) &&
+      (stats[0].switch_attempts ==
+       stats[0].switch_fail + stats[0].switch_success) &&
+      (stats[1].switch_attempts ==
+       stats[1].switch_fail + stats[1].switch_success))
+  {
+    bytes_recv_after_switch += ntohs (hdr->header.size);
+    if ((bytes_sent_after_switch > 0) && (bytes_recv_after_switch > 0))
+    {
+      /* A peer switched addresses and sent and received data after the
+       * switch operations */
+      GNUNET_SCHEDULER_shutdown ();
+    }
+  }
+}
+
+
+static void
+notify_send (void *cls)
+{
+  static uint32_t cnt;
+
+  GNUNET_assert (
+    GNUNET_OK ==
+    GNUNET_TRANSPORT_TESTING_send (ccc->p[1],
+                                   ccc->p[0],
+                                   GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE,
+                                   GNUNET_TRANSPORT_TESTING_LARGE_MESSAGE_SIZE,
+                                   ++cnt,
+                                   &notify_send,
+                                   NULL));
+  if (((stats[0].switch_attempts >= 1) || (stats[1].switch_attempts >= 1)) &&
+      (stats[0].switch_attempts ==
+       stats[0].switch_fail + stats[0].switch_success) &&
+      (stats[1].switch_attempts ==
+       stats[1].switch_fail + stats[1].switch_success))
+  {
+    bytes_sent_after_switch += GNUNET_TRANSPORT_TESTING_LARGE_MESSAGE_SIZE;
+  }
+}
+
+
+static void
+progress_indicator (void *cls)
+{
+  static int counter;
+
+  measure_task = NULL;
+  counter++;
+  if ((TIMEOUT.rel_value_us / 1000 / 1000LL) < counter)
+  {
+    fprintf (stderr, "%s", ".\n");
+  }
+  else
+  {
+    fprintf (stderr, "%s", ".");
+    measure_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                                 &progress_indicator,
+                                                 NULL);
+  }
+}
+
+
+static void
+connected_cb (void *cls)
+{
+  for (unsigned int i = 0; i < 2; i++)
+  {
+    stats[i].stat = GNUNET_STATISTICS_create ("transport", ccc->p[i]->cfg);
+    if (NULL == stats[i].stat)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Fail! Could not create statistics for peers!\n");
+      ccc->global_ret = GNUNET_SYSERR;
+      GNUNET_SCHEDULER_shutdown ();
+      return;
+    }
+    for (unsigned int j = 0; NULL != watches[j].stat_name; j++)
+    {
+      GNUNET_STATISTICS_watch (stats[i].stat,
+                               "transport",
+                               watches[j].stat_name,
+                               watches[j].stat_handler,
+                               &stats[i]);
+    }
+  }
+  /* Show progress */
+  ccc->global_ret = GNUNET_OK;
+  measure_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                               &progress_indicator,
+                                               NULL);
+  /* Peers are connected, start transmit test messages */
+  GNUNET_assert (
+    GNUNET_OK ==
+    GNUNET_TRANSPORT_TESTING_send (ccc->p[1],
+                                   ccc->p[0],
+                                   GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE,
+                                   GNUNET_TRANSPORT_TESTING_LARGE_MESSAGE_SIZE,
+                                   0,
+                                   &notify_send,
+                                   NULL));
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext my_ccc =
+  { .connect_continuation = &connected_cb,
+    .config_file = "test_transport_api_data.conf",
+    .rec = &notify_receive,
+    .nc = &GNUNET_TRANSPORT_TESTING_log_connect,
+    .shutdown_task = &custom_shutdown,
+    .timeout = TIMEOUT };
+
+  ccc = &my_ccc;
+  int ret;
+
+  ret = GNUNET_TRANSPORT_TESTING_main (2,
+                                       &GNUNET_TRANSPORT_TESTING_connect_check,
+                                       ccc);
+  if (77 == ret)
+    return 77;
+  if (GNUNET_OK != ret)
+    return 1;
+  return 0;
+}
+
+
+/* end of test_transport_address_switch.c */
diff --git a/src/service/transport/test_transport_address_switch_tcp_peer1.conf b/src/service/transport/test_transport_address_switch_tcp_peer1.conf
new file mode 100644
index 000000000..cfcbfe41c
--- /dev/null
+++ b/src/service/transport/test_transport_address_switch_tcp_peer1.conf
@@ -0,0 +1,48 @@
+@INLINE@ template_cfg_peer1.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-p1/
+
+[ats]
+UNSPECIFIED_QUOTA_IN = 8 KiB
+UNSPECIFIED_QUOTA_OUT = 8 KiB
+# LOOPBACK
+LOOPBACK_QUOTA_IN = 8 KiB
+LOOPBACK_QUOTA_OUT = 8 KiB
+# LAN
+LAN_QUOTA_IN = 8 KiB
+LAN_QUOTA_OUT = 8 KiB
+# WAN
+WAN_QUOTA_IN = 8 KiB
+WAN_QUOTA_OUT = 8 KiB
+# WLAN
+WLAN_QUOTA_IN = 8 KiB
+WLAN_QUOTA_OUT = 8 KiB
+# BLUETOOTH
+BLUETOOTH_QUOTA_IN = 8 KiB
+BLUETOOTH_QUOTA_OUT = 8 KiB
+
+[transport-tcp]
+PORT = 12000
+TIMEOUT = 5 s
+
+[arm]
+PORT = 12005
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-arm.sock
+
+[statistics]
+PORT = 12004
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-statistics.sock
+
+[resolver]
+PORT = 12003
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-resolver.sock
+
+[peerinfo]
+PORT = 12002
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-peerinfo.sock
+
+[transport]
+PORT = 12001
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-transport.sock
+PLUGINS = tcp
+
diff --git a/src/service/transport/test_transport_address_switch_tcp_peer2.conf b/src/service/transport/test_transport_address_switch_tcp_peer2.conf
new file mode 100644
index 000000000..bda2354b6
--- /dev/null
+++ b/src/service/transport/test_transport_address_switch_tcp_peer2.conf
@@ -0,0 +1,48 @@
+@INLINE@ template_cfg_peer2.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-p2/
+
+[ats]
+UNSPECIFIED_QUOTA_IN = 8 KiB
+UNSPECIFIED_QUOTA_OUT = 8 KiB
+# LOOPBACK
+LOOPBACK_QUOTA_IN = 8 KiB
+LOOPBACK_QUOTA_OUT = 8 KiB
+# LAN
+LAN_QUOTA_IN = 8 KiB
+LAN_QUOTA_OUT = 8 KiB
+# WAN
+WAN_QUOTA_IN = 8 KiB
+WAN_QUOTA_OUT = 8 KiB
+# WLAN
+WLAN_QUOTA_IN = 8 KiB
+WLAN_QUOTA_OUT = 8 KiB
+# BLUETOOTH
+BLUETOOTH_QUOTA_IN = 8 KiB
+BLUETOOTH_QUOTA_OUT = 8 KiB
+
+[transport-tcp]
+PORT = 12015
+TIMEOUT = 5 s
+
+[arm]
+PORT = 12014
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-arm.sock
+
+[statistics]
+PORT = 12013
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-statistics.sock
+
+[resolver]
+PORT = 12012
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-resolver.sock
+
+[peerinfo]
+PORT = 12011
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-peerinfo.sock
+
+[transport]
+PORT = 12010
+PLUGINS = tcp
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-transport.sock
+
diff --git a/src/service/transport/test_transport_address_switch_udp_peer1.conf b/src/service/transport/test_transport_address_switch_udp_peer1.conf
new file mode 100644
index 000000000..bdc3a2253
--- /dev/null
+++ b/src/service/transport/test_transport_address_switch_udp_peer1.conf
@@ -0,0 +1,48 @@
+@INLINE@ template_cfg_peer1.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-p1/
+
+[ats]
+UNSPECIFIED_QUOTA_IN = 8 KiB
+UNSPECIFIED_QUOTA_OUT = 8 KiB
+# LOOPBACK
+LOOPBACK_QUOTA_IN = 8 KiB
+LOOPBACK_QUOTA_OUT = 8 KiB
+# LAN
+LAN_QUOTA_IN = 8 KiB
+LAN_QUOTA_OUT = 8 KiB
+# WAN
+WAN_QUOTA_IN = 8 KiB
+WAN_QUOTA_OUT = 8 KiB
+# WLAN
+WLAN_QUOTA_IN = 8 KiB
+WLAN_QUOTA_OUT = 8 KiB
+# BLUETOOTH
+BLUETOOTH_QUOTA_IN = 8 KiB
+BLUETOOTH_QUOTA_OUT = 8 KiB
+
+[transport-tcp]
+PORT = 12000
+TIMEOUT = 5 s
+
+[arm]
+PORT = 12005
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-arm.sock
+
+[statistics]
+PORT = 12004
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-statistics.sock
+
+[resolver]
+PORT = 12003
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-resolver.sock
+
+[peerinfo]
+PORT = 12002
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-peerinfo.sock
+
+[transport]
+PORT = 12001
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-transport.sock
+PLUGINS = udp
+
diff --git a/src/service/transport/test_transport_address_switch_udp_peer2.conf b/src/service/transport/test_transport_address_switch_udp_peer2.conf
new file mode 100644
index 000000000..ae6397db4
--- /dev/null
+++ b/src/service/transport/test_transport_address_switch_udp_peer2.conf
@@ -0,0 +1,48 @@
+@INLINE@ template_cfg_peer2.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-p2/
+
+[ats]
+UNSPECIFIED_QUOTA_IN = 8 KiB
+UNSPECIFIED_QUOTA_OUT = 8 KiB
+# LOOPBACK
+LOOPBACK_QUOTA_IN = 8 KiB
+LOOPBACK_QUOTA_OUT = 8 KiB
+# LAN
+LAN_QUOTA_IN = 8 KiB
+LAN_QUOTA_OUT = 8 KiB
+# WAN
+WAN_QUOTA_IN = 8 KiB
+WAN_QUOTA_OUT = 8 KiB
+# WLAN
+WLAN_QUOTA_IN = 8 KiB
+WLAN_QUOTA_OUT = 8 KiB
+# BLUETOOTH
+BLUETOOTH_QUOTA_IN = 8 KiB
+BLUETOOTH_QUOTA_OUT = 8 KiB
+
+[transport-tcp]
+PORT = 12015
+TIMEOUT = 5 s
+
+[arm]
+PORT = 12014
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-arm.sock
+
+[statistics]
+PORT = 12013
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-statistics.sock
+
+[resolver]
+PORT = 12012
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-resolver.sock
+
+[peerinfo]
+PORT = 12011
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-peerinfo.sock
+
+[transport]
+PORT = 12010
+PLUGINS = udp
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-transport.sock
+
diff --git a/src/service/transport/test_transport_api.c b/src/service/transport/test_transport_api.c
new file mode 100644
index 000000000..5f5e03a9e
--- /dev/null
+++ b/src/service/transport/test_transport_api.c
@@ -0,0 +1,126 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009, 2010, 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 transport/test_transport_api.c
+ * @brief base test case for transport implementations
+ * @author Christian Grothoff
+ *
+ * This test case serves as a base for tcp, udp, and udp-nat
+ * transport test cases.  Based on the executable being run
+ * the correct test case will be performed.  Conservation of
+ * C code apparently.
+ */
+#include "platform.h"
+#include "gnunet_transport_service.h"
+#include "transport-testing.h"
+
+/**
+ * How long until we give up on transmitting the message?
+ */
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
+
+static struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc;
+
+
+static void
+notify_receive (void *cls,
+                struct GNUNET_TRANSPORT_TESTING_PeerContext *receiver,
+                const struct GNUNET_PeerIdentity *sender,
+                const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
+{
+  {
+    char *ps = GNUNET_strdup (GNUNET_i2s (&receiver->id));
+
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Peer %u (`%s') received message of type %d and size %u size from peer %s!\n",
+                receiver->no,
+                ps,
+                ntohs (message->header.type),
+                ntohs (message->header.size),
+                GNUNET_i2s (sender));
+    GNUNET_free (ps);
+  }
+
+  if ((GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE == ntohs (message->header.type)) &&
+      (GNUNET_TRANSPORT_TESTING_LARGE_MESSAGE_SIZE == ntohs (
+         message->header.size)))
+  {
+    ccc->global_ret = GNUNET_OK;
+    GNUNET_SCHEDULER_shutdown ();
+  }
+  else
+  {
+    GNUNET_break (0);
+    ccc->global_ret = GNUNET_SYSERR;
+    GNUNET_SCHEDULER_shutdown ();
+  }
+}
+
+
+/**
+ * Runs the test.
+ *
+ * @param argv the argv argument from main()
+ * @param bi_directional should we try to establish connections
+ *        in both directions simultaneously?
+ */
+static int
+test (char *argv[],
+      int bi_directional)
+{
+  struct GNUNET_TRANSPORT_TESTING_SendClosure sc = {
+    .num_messages = 1
+  };
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext my_ccc = {
+    .connect_continuation = &GNUNET_TRANSPORT_TESTING_large_send,
+    .connect_continuation_cls = &sc,
+    .config_file = "test_transport_api_data.conf",
+    .rec = &notify_receive,
+    .nc = &GNUNET_TRANSPORT_TESTING_log_connect,
+    .nd = &GNUNET_TRANSPORT_TESTING_log_disconnect,
+    .timeout = TIMEOUT,
+    .bi_directional = bi_directional
+  };
+
+  ccc = &my_ccc;
+  sc.ccc = ccc;
+  if (GNUNET_OK !=
+      GNUNET_TRANSPORT_TESTING_main (2,
+                                     &GNUNET_TRANSPORT_TESTING_connect_check,
+                                     ccc))
+    return 1;
+  return 0;
+}
+
+
+int
+main (int argc,
+      char *argv[])
+{
+  if ((0 != test (argv,
+                  GNUNET_NO)) ||
+      (0 != test (argv,
+                  GNUNET_YES)))
+    return 1;
+  return 0;
+}
+
+
+/* end of test_transport_api.c */
diff --git a/src/service/transport/test_transport_api2.c b/src/service/transport/test_transport_api2.c
new file mode 100644
index 000000000..4d423f7c2
--- /dev/null
+++ b/src/service/transport/test_transport_api2.c
@@ -0,0 +1,126 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009, 2010, 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 transport/test_transport_api.c
+ * @brief base test case for transport implementations
+ * @author Christian Grothoff
+ *
+ * This test case serves as a base for tcp, udp, and udp-nat
+ * transport test cases.  Based on the executable being run
+ * the correct test case will be performed.  Conservation of
+ * C code apparently.
+ */
+#include "platform.h"
+// #include "gnunet_transport_service.h"
+#include "transport-testing2.h"
+
+/**
+ * How long until we give up on transmitting the message?
+ */
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
+
+static struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc;
+
+
+static void
+notify_receive (void *cls,
+                struct GNUNET_TRANSPORT_TESTING_PeerContext *receiver,
+                const struct GNUNET_PeerIdentity *sender,
+                const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
+{
+  {
+    char *ps = GNUNET_strdup (GNUNET_i2s (&receiver->id));
+
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Peer %u (`%s') received message of type %d and size %u size from peer %s!\n",
+                receiver->no,
+                ps,
+                ntohs (message->header.type),
+                ntohs (message->header.size),
+                GNUNET_i2s (sender));
+    GNUNET_free (ps);
+  }
+
+  if ((GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE == ntohs (message->header.type)) &&
+      (GNUNET_TRANSPORT_TESTING_LARGE_MESSAGE_SIZE == ntohs (
+         message->header.size)))
+  {
+    ccc->global_ret = GNUNET_OK;
+    GNUNET_SCHEDULER_shutdown ();
+  }
+  else
+  {
+    GNUNET_break (0);
+    ccc->global_ret = GNUNET_SYSERR;
+    GNUNET_SCHEDULER_shutdown ();
+  }
+}
+
+
+/**
+ * Runs the test.
+ *
+ * @param argv the argv argument from main()
+ * @param bi_directional should we try to establish connections
+ *        in both directions simultaneously?
+ */
+static int
+test (char *argv[],
+      int bi_directional)
+{
+  struct GNUNET_TRANSPORT_TESTING_SendClosure sc = {
+    .num_messages = 1
+  };
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext my_ccc = {
+    .connect_continuation = &GNUNET_TRANSPORT_TESTING_large_send,
+    .connect_continuation_cls = &sc,
+    .config_file = "test_transport_api_data.conf",
+    .rec = &notify_receive,
+    .nc = &GNUNET_TRANSPORT_TESTING_log_connect,
+    .nd = &GNUNET_TRANSPORT_TESTING_log_disconnect,
+    .timeout = TIMEOUT,
+    .bi_directional = bi_directional
+  };
+
+  ccc = &my_ccc;
+  sc.ccc = ccc;
+  if (GNUNET_OK !=
+      GNUNET_TRANSPORT_TESTING_main (2,
+                                     &GNUNET_TRANSPORT_TESTING_connect_check,
+                                     ccc))
+    return 1;
+  return 0;
+}
+
+
+int
+main (int argc,
+      char *argv[])
+{
+  if ((0 != test (argv,
+                  GNUNET_NO)) ||
+      (0 != test (argv,
+                  GNUNET_YES)))
+    return 1;
+  return 0;
+}
+
+
+/* end of test_transport_api.c */
diff --git a/src/service/transport/test_transport_api2_tcp_node1.conf b/src/service/transport/test_transport_api2_tcp_node1.conf
new file mode 100644
index 000000000..463ec61d8
--- /dev/null
+++ b/src/service/transport/test_transport_api2_tcp_node1.conf
@@ -0,0 +1,35 @@
+@INLINE@ template_cfg_peer1.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-p1/
+
+[transport]
+BINARY = gnunet-service-transport
+PLUGINS = tcp
+#PREFIX = valgrind --leak-check=full --track-origins=yes --trace-children=yes --log-file=$GNUNET_TEST_HOME/vg_peer1-%p 
+UNIXPATH = $GNUNET_RUNTIME_DIR/tng-p1.sock
+
+[PEER]
+PRIVATE_KEY = $GNUNET_RUNTIME_DIR/private.key
+
+[communicator-tcp]
+BINARY = gnunet-communicator-tcp
+BINDTO = 192.168.15.1:60002
+DISABLE_V6 = YES
+IMMEDIATE_START = YES
+UNIXPATH = $GNUNET_RUNTIME_DIR/tcp-comm-p1.sock
+#PREFIX = valgrind --leak-check=full --track-origins=yes --trace-children=yes --log-file=$GNUNET_TEST_HOME/vg_ctpeer1-%p
+#PREFIX = xterm -geometry 100x85 -T peer1 -e gdb --args
+
+[communicator-udp]
+#PREFIX = valgrind --leak-check=full --track-origins=yes --trace-children=yes --log-file=$GNUNET_TEST_HOME/vg_cupeer1-%p
+BINARY = gnunet-communicator-udp
+BINDTO = 192.168.15.1:60002
+DISABLE_V6 = YES
+IMMEDIATE_START = YES
+UNIXPATH = $GNUNET_RUNTIME_DIR/udp-comm-p1.sock
+
+[peerstore]
+IMMEDIATE_START = YES
+
+#[transport]
+#PREFIX = valgrind
diff --git a/src/service/transport/test_transport_api2_tcp_node2.conf b/src/service/transport/test_transport_api2_tcp_node2.conf
new file mode 100644
index 000000000..b7f92869e
--- /dev/null
+++ b/src/service/transport/test_transport_api2_tcp_node2.conf
@@ -0,0 +1,22 @@
+@INLINE@ template_cfg_peer2.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-p2/
+
+[transport]
+BINARY = gnunet-service-transport
+#PREFIX = valgrind --log-file=$GNUNET_TEST_HOME/vg_peer2-%p
+UNIXPATH = $GNUNET_RUNTIME_DIR/tng-p2.sock
+
+[communicator-tcp]
+BINARY = gnunet-communicator-tcp
+BINDTO = 192.168.15.2:60003
+DISABLE_V6 = YES
+IMMEDIATE_START = YES
+#PREFIX = valgrind --log-file=$GNUNET_TEST_HOME/vg_comm2-%p
+UNIXPATH = $GNUNET_RUNTIME_DIR/tcp-comm-p2.sock
+
+[peerstore]
+IMMEDIATE_START = YES
+
+#[transport]
+#PREFIX = valgrind
diff --git a/src/service/transport/test_transport_api2_tcp_peer1.conf b/src/service/transport/test_transport_api2_tcp_peer1.conf
new file mode 100644
index 000000000..54ec9fd9f
--- /dev/null
+++ b/src/service/transport/test_transport_api2_tcp_peer1.conf
@@ -0,0 +1,23 @@
+@INLINE@ template_cfg_peer1.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-p1/
+
+[transport]
+BINARY = gnunet-service-transport
+PLUGINS = tcp
+#PREFIX = valgrind --log-file=$GNUNET_TEST_HOME/vg_peer1-%p
+UNIXPATH = $GNUNET_RUNTIME_DIR/tng-p1.sock
+
+[communicator-tcp]
+BINARY = gnunet-communicator-tcp
+BINDTO = 60002
+DISABLE_V6 = YES
+IMMEDIATE_START = YES
+UNIXPATH = $GNUNET_RUNTIME_DIR/tcp-comm-p1.sock
+#PREFIX = valgrind --log-file=$GNUNET_TEST_HOME/vg_cpeer1-%p
+
+[peerstore]
+IMMEDIATE_START = YES
+
+#[transport]
+#PREFIX = valgrind
diff --git a/src/service/transport/test_transport_api2_tcp_peer2.conf b/src/service/transport/test_transport_api2_tcp_peer2.conf
new file mode 100644
index 000000000..7ae5ac697
--- /dev/null
+++ b/src/service/transport/test_transport_api2_tcp_peer2.conf
@@ -0,0 +1,22 @@
+@INLINE@ template_cfg_peer2.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-p2/
+
+[transport]
+BINARY = gnunet-service-transport
+#PREFIX = valgrind --log-file=$GNUNET_TEST_HOME/vg_peer2-%p
+UNIXPATH = $GNUNET_RUNTIME_DIR/tng-p2.sock
+
+[communicator-tcp]
+BINARY = gnunet-communicator-tcp
+BINDTO = 60003
+DISABLE_V6 = YES
+IMMEDIATE_START = YES
+#PREFIX = valgrind --log-file=$GNUNET_TEST_HOME/vg_comm2-%p
+UNIXPATH = $GNUNET_RUNTIME_DIR/tcp-comm-p2.sock
+
+[peerstore]
+IMMEDIATE_START = YES
+
+#[transport]
+#PREFIX = valgrind
diff --git a/src/service/transport/test_transport_api2_tng_node.conf b/src/service/transport/test_transport_api2_tng_node.conf
new file mode 100644
index 000000000..c50ccf662
--- /dev/null
+++ b/src/service/transport/test_transport_api2_tng_node.conf
@@ -0,0 +1,40 @@
+@INLINE@ template_tng_cfg_peer1.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-p1/
+
+[transport]
+BINARY = gnunet-service-transport
+#PREFIX = valgrind --leak-check=full --track-origins=yes --trace-children=yes --log-file=$GNUNET_TEST_HOME/vg_peer1-%p 
+UNIXPATH = $GNUNET_RUNTIME_DIR/tng-p1.sock
+
+[PEER]
+PRIVATE_KEY = $GNUNET_RUNTIME_DIR/private.key
+
+[communicator-tcp]
+BINARY = gnunet-communicator-tcp
+BINDTO = 192.168.15.1:60002
+DISABLE_V6 = YES
+IMMEDIATE_START = YES
+UNIXPATH = $GNUNET_RUNTIME_DIR/tcp-comm-p1.sock
+#PREFIX = valgrind --leak-check=full --track-origins=yes --trace-children=yes --log-file=$GNUNET_TEST_HOME/vg_ctpeer1-%p
+#PREFIX = xterm -geometry 100x85 -T peer1 -e gdb --args
+
+[communicator-udp]
+#PREFIX = valgrind --leak-check=full --track-origins=yes --trace-children=yes --log-file=$GNUNET_TEST_HOME/vg_cupeer1-%p
+BINARY = gnunet-communicator-udp
+BINDTO = 192.168.15.1:60002
+DISABLE_V6 = YES
+IMMEDIATE_START = YES
+UNIXPATH = $GNUNET_RUNTIME_DIR/udp-comm-p1.sock
+
+[peerstore]
+IMMEDIATE_START = YES
+
+[topology]
+IMMEDIATE_START = YES
+
+[dht]
+IMMEDIATE_START = YES
+
+[fs]
+IMMEDIATE_START = YES
diff --git a/src/service/transport/test_transport_api_data.conf b/src/service/transport/test_transport_api_data.conf
new file mode 100644
index 000000000..c06235a0a
--- /dev/null
+++ b/src/service/transport/test_transport_api_data.conf
@@ -0,0 +1,9 @@
+@INLINE@ test_transport_defaults.conf
+[PATHS]
+
+[transport-tcp]
+PORT = 52094
+
+[transport-udp]
+PORT = 52094
+
diff --git a/src/service/transport/test_transport_api_monitor_peers.c b/src/service/transport/test_transport_api_monitor_peers.c
new file mode 100644
index 000000000..c09e3782d
--- /dev/null
+++ b/src/service/transport/test_transport_api_monitor_peers.c
@@ -0,0 +1,226 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009, 2010, 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 transport/test_transport_api_monitor_peers.c
+ * @brief base test case for transport peer monitor API
+ */
+#include "platform.h"
+#include "gnunet_transport_service.h"
+#include "transport-testing.h"
+
+/**
+ * How long until we give up on transmitting the message?
+ */
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)
+
+/**
+ * How long until we give up on transmitting the message?
+ */
+#define TIMEOUT_TRANSMIT GNUNET_TIME_relative_multiply ( \
+    GNUNET_TIME_UNIT_SECONDS, 30)
+
+#define TEST_MESSAGE_SIZE 2600
+
+#define TEST_MESSAGE_TYPE 12345
+
+static struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc;
+
+static struct GNUNET_TRANSPORT_PeerMonitoringContext *pmc_p1;
+
+static struct GNUNET_TRANSPORT_PeerMonitoringContext *pmc_p2;
+
+static int p1_c;
+
+static int p2_c;
+
+static int p1_c_notify;
+
+static int p2_c_notify;
+
+
+static void
+custom_shutdown (void *cls)
+{
+  if (NULL != pmc_p1)
+  {
+    GNUNET_TRANSPORT_monitor_peers_cancel (pmc_p1);
+    pmc_p1 = NULL;
+  }
+  if (NULL != pmc_p2)
+  {
+    GNUNET_TRANSPORT_monitor_peers_cancel (pmc_p2);
+    pmc_p2 = NULL;
+  }
+}
+
+
+static void
+notify_receive (void *cls,
+                struct GNUNET_TRANSPORT_TESTING_PeerContext *receiver,
+                const struct GNUNET_PeerIdentity *sender,
+                const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
+{
+  char *ps = GNUNET_strdup (GNUNET_i2s (&receiver->id));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Peer %u (`%s') received message of type %d and size %u size from peer %s!\n",
+              receiver->no,
+              ps,
+              ntohs (message->header.type),
+              ntohs (message->header.size),
+              GNUNET_i2s (sender));
+  GNUNET_free (ps);
+}
+
+
+static void
+sendtask (void *cls)
+{
+  /* intentionally empty */
+}
+
+
+static void
+check_done ()
+{
+  if ((GNUNET_YES == p1_c) &&
+      (GNUNET_YES == p2_c) &&
+      p1_c_notify &&
+      p2_c_notify)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Both peers state to be connected\n");
+    ccc->global_ret = GNUNET_OK;
+    GNUNET_SCHEDULER_shutdown ();
+  }
+}
+
+
+static void
+notify_connect (void *cls,
+                struct GNUNET_TRANSPORT_TESTING_PeerContext *me,
+                const struct GNUNET_PeerIdentity *other)
+{
+  GNUNET_TRANSPORT_TESTING_log_connect (cls,
+                                        me,
+                                        other);
+  if (0 == memcmp (other, &ccc->p[0]->id, sizeof(struct GNUNET_PeerIdentity)))
+  {
+    p1_c_notify = GNUNET_YES;
+  }
+  if (0 == memcmp (other, &ccc->p[1]->id, sizeof(struct GNUNET_PeerIdentity)))
+  {
+    p2_c_notify = GNUNET_YES;
+  }
+  check_done ();
+}
+
+
+static void
+monitor1_cb (void *cls,
+             const struct GNUNET_PeerIdentity *peer,
+             const struct GNUNET_HELLO_Address *address,
+             enum GNUNET_TRANSPORT_PeerState state,
+             struct GNUNET_TIME_Absolute state_timeout)
+{
+  if ((NULL == address) || (NULL == ccc->p[0]))
+    return;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Monitor 1: %s %s %s\n",
+              GNUNET_i2s (&address->peer),
+              GNUNET_TRANSPORT_ps2s (state),
+              GNUNET_STRINGS_absolute_time_to_string (state_timeout));
+  if ((0 == memcmp (&address->peer, &ccc->p[1]->id, sizeof(ccc->p[1]->id))) &&
+      (GNUNET_YES == GNUNET_TRANSPORT_is_connected (state)) &&
+      (GNUNET_NO == p1_c))
+  {
+    p1_c = GNUNET_YES;
+    check_done ();
+  }
+}
+
+
+static void
+monitor2_cb (void *cls,
+             const struct GNUNET_PeerIdentity *peer,
+             const struct GNUNET_HELLO_Address *address,
+             enum GNUNET_TRANSPORT_PeerState state,
+             struct GNUNET_TIME_Absolute state_timeout)
+{
+  if ((NULL == address) || (NULL == ccc->p[1]))
+    return;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Monitor 2: %s %s %s\n",
+              GNUNET_i2s (&address->peer),
+              GNUNET_TRANSPORT_ps2s (state),
+              GNUNET_STRINGS_absolute_time_to_string (state_timeout));
+  if ((0 == memcmp (&address->peer, &ccc->p[0]->id, sizeof(ccc->p[0]->id))) &&
+      (GNUNET_YES == GNUNET_TRANSPORT_is_connected (state)) &&
+      (GNUNET_NO == p2_c))
+  {
+    p2_c = GNUNET_YES;
+    check_done ();
+  }
+}
+
+
+static void
+start_monitors (void *cls)
+{
+  pmc_p1 = GNUNET_TRANSPORT_monitor_peers (ccc->p[0]->cfg,
+                                           NULL,
+                                           GNUNET_NO,
+                                           &monitor1_cb,
+                                           NULL);
+  pmc_p2 = GNUNET_TRANSPORT_monitor_peers (ccc->p[1]->cfg,
+                                           NULL,
+                                           GNUNET_NO,
+                                           &monitor2_cb,
+                                           NULL);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext my_ccc = {
+    .pre_connect_task = &start_monitors,
+    .connect_continuation = &sendtask,
+    .config_file = "test_transport_api_data.conf",
+    .rec = &notify_receive,
+    .nc = &notify_connect,
+    .nd = &GNUNET_TRANSPORT_TESTING_log_disconnect,
+    .shutdown_task = &custom_shutdown,
+    .timeout = TIMEOUT
+  };
+
+  ccc = &my_ccc;
+  if (GNUNET_OK !=
+      GNUNET_TRANSPORT_TESTING_main (2,
+                                     &GNUNET_TRANSPORT_TESTING_connect_check,
+                                     ccc))
+    return 1;
+  return 0;
+}
+
+
+/* end of test_transport_api_monitor_peers.c */
diff --git a/src/service/transport/test_transport_api_monitor_peers_peer1.conf b/src/service/transport/test_transport_api_monitor_peers_peer1.conf
new file mode 100644
index 000000000..bc9eee19b
--- /dev/null
+++ b/src/service/transport/test_transport_api_monitor_peers_peer1.conf
@@ -0,0 +1,4 @@
+@INLINE@ template_cfg_peer1.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-monitoring-p1/
+
diff --git a/src/service/transport/test_transport_api_monitor_peers_peer2.conf b/src/service/transport/test_transport_api_monitor_peers_peer2.conf
new file mode 100644
index 000000000..5225a5a87
--- /dev/null
+++ b/src/service/transport/test_transport_api_monitor_peers_peer2.conf
@@ -0,0 +1,5 @@
+@INLINE@ template_cfg_peer2.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-monitoring-p2/
+
+
diff --git a/src/service/transport/test_transport_api_monitor_validation_peer1.conf b/src/service/transport/test_transport_api_monitor_validation_peer1.conf
new file mode 100644
index 000000000..02f7bc2f0
--- /dev/null
+++ b/src/service/transport/test_transport_api_monitor_validation_peer1.conf
@@ -0,0 +1,6 @@
+@INLINE@ template_cfg_peer1.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-monitoring-val-p1/
+
+[transport]
+PLUGINS=tcp
diff --git a/src/service/transport/test_transport_api_monitor_validation_peer2.conf b/src/service/transport/test_transport_api_monitor_validation_peer2.conf
new file mode 100644
index 000000000..d4e0874f0
--- /dev/null
+++ b/src/service/transport/test_transport_api_monitor_validation_peer2.conf
@@ -0,0 +1,7 @@
+@INLINE@ template_cfg_peer2.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-monitoring-val-p2/
+
+[TRANSPORT]
+PLUGINS=tcp
+
diff --git a/src/service/transport/test_transport_api_multi_peer1.conf b/src/service/transport/test_transport_api_multi_peer1.conf
new file mode 100644
index 000000000..b7cb98777
--- /dev/null
+++ b/src/service/transport/test_transport_api_multi_peer1.conf
@@ -0,0 +1,7 @@
+@INLINE@ template_cfg_peer1.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-multi-p1/
+
+[transport]
+PLUGINS = tcp udp
+
diff --git a/src/service/transport/test_transport_api_multi_peer2.conf b/src/service/transport/test_transport_api_multi_peer2.conf
new file mode 100644
index 000000000..f69e0abd9
--- /dev/null
+++ b/src/service/transport/test_transport_api_multi_peer2.conf
@@ -0,0 +1,9 @@
+@INLINE@ template_cfg_peer2.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-multi-p2/
+
+[nat]
+ALLOW_NAT = NO
+
+[transport]
+PLUGINS = tcp udp
diff --git a/src/service/transport/test_transport_api_tcp_nat_peer1.conf b/src/service/transport/test_transport_api_tcp_nat_peer1.conf
new file mode 100644
index 000000000..fb2fcecc6
--- /dev/null
+++ b/src/service/transport/test_transport_api_tcp_nat_peer1.conf
@@ -0,0 +1,34 @@
+@INLINE@ template_cfg_peer1.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-nat-p1/
+
+[nat]
+BEHIND_NAT = YES
+ENABLE_NAT_SERVER = YES
+DISABLEV6 = YES
+
+[transport-tcp]
+PORT = 0
+TIMEOUT = 5 s
+
+[arm]
+PORT = 51204
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-arm.sock
+
+[statistics]
+PORT = 12023
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-statistics.sock
+
+[resolver]
+PORT = 12022
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-resolver.sock
+
+[peerinfo]
+PORT = 12021
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-peerinfo.sock
+
+[transport]
+PORT = 29542
+PLUGINS = tcp
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-transport.sock
+
diff --git a/src/service/transport/test_transport_api_tcp_nat_peer2.conf b/src/service/transport/test_transport_api_tcp_nat_peer2.conf
new file mode 100644
index 000000000..1faefc195
--- /dev/null
+++ b/src/service/transport/test_transport_api_tcp_nat_peer2.conf
@@ -0,0 +1,32 @@
+@INLINE@ template_cfg_peer2.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-nat-p2/
+
+[nat]
+DISABLEV6 = YES
+ENABLE_NAT_CLIENT = YES
+
+[transport-tcp]
+PORT = 12030
+TIMEOUT = 5 s
+
+[arm]
+PORT = 12034
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-arm.sock
+
+[statistics]
+PORT = 12033
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-statistics.sock
+
+[resolver]
+PORT = 12032
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-resolver.sock
+
+[peerinfo]
+PORT = 12031
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-peerinfo.sock
+
+[transport]
+PORT = 45923
+PLUGINS = tcp
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-transport.sock
diff --git a/src/service/transport/test_transport_api_tcp_peer1.conf b/src/service/transport/test_transport_api_tcp_peer1.conf
new file mode 100644
index 000000000..eabd6b701
--- /dev/null
+++ b/src/service/transport/test_transport_api_tcp_peer1.conf
@@ -0,0 +1,9 @@
+@INLINE@ template_cfg_peer1.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-p1/
+
+[transport]
+PLUGINS = tcp
+
+#[transport]
+#PREFIX = valgrind
diff --git a/src/service/transport/test_transport_api_tcp_peer2.conf b/src/service/transport/test_transport_api_tcp_peer2.conf
new file mode 100644
index 000000000..58ce0777f
--- /dev/null
+++ b/src/service/transport/test_transport_api_tcp_peer2.conf
@@ -0,0 +1,9 @@
+@INLINE@ template_cfg_peer2.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-p2/
+
+[transport]
+PLUGINS = tcp
+
+#[transport]
+#PREFIX = valgrind
diff --git a/src/service/transport/test_transport_api_udp_nat_peer1.conf b/src/service/transport/test_transport_api_udp_nat_peer1.conf
new file mode 100644
index 000000000..7bbcaa628
--- /dev/null
+++ b/src/service/transport/test_transport_api_udp_nat_peer1.conf
@@ -0,0 +1,34 @@
+@INLINE@ template_cfg_peer1.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-udp-nat-p1/
+
+[nat]
+BEHIND_NAT = YES
+ALLOW_NAT = NO
+ONLY_NAT_ADDRESSES = YES
+
+[transport-udp]
+PORT = 0
+
+[arm]
+PORT = 12065
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-arm.sock
+
+[statistics]
+PORT = 12064
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-statistics.sock
+
+[resolver]
+PORT = 12063
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-resolver.sock
+
+[peerinfo]
+PORT = 12062
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-peerinfo.sock
+
+[transport]
+PORT = 12061
+PLUGINS = udp
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-transport.sock
+
+
diff --git a/src/service/transport/test_transport_api_udp_nat_peer2.conf b/src/service/transport/test_transport_api_udp_nat_peer2.conf
new file mode 100644
index 000000000..8bdb8c293
--- /dev/null
+++ b/src/service/transport/test_transport_api_udp_nat_peer2.conf
@@ -0,0 +1,32 @@
+@INLINE@ template_cfg_peer2.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-udp-nat-p2/
+
+[nat]
+ALLOW_NAT = YES
+
+[transport-udp]
+PORT = 12070
+
+[arm]
+PORT = 12075
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-arm.sock
+
+[statistics]
+PORT = 12074
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-statistics.sock
+
+[resolver]
+PORT = 12073
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-resolver.sock
+
+[peerinfo]
+PORT = 12072
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-peerinfo.sock
+
+[transport]
+PORT = 12071
+PLUGINS = udp
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-transport.sock
+
+
diff --git a/src/service/transport/test_transport_api_udp_peer1.conf b/src/service/transport/test_transport_api_udp_peer1.conf
new file mode 100644
index 000000000..4684b77f2
--- /dev/null
+++ b/src/service/transport/test_transport_api_udp_peer1.conf
@@ -0,0 +1,17 @@
+@INLINE@ template_cfg_peer1.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-udp-p1/
+
+[transport-udp]
+PORT = 0
+BROADCAST = NO
+MAX_BPS = 50000000
+BINDTO = 127.0.0.1
+BINDTO6 = ::1
+
+[transport]
+PORT = 12041
+PLUGINS = udp
+
+
+
diff --git a/src/service/transport/test_transport_api_udp_peer2.conf b/src/service/transport/test_transport_api_udp_peer2.conf
new file mode 100644
index 000000000..96706ce49
--- /dev/null
+++ b/src/service/transport/test_transport_api_udp_peer2.conf
@@ -0,0 +1,15 @@
+@INLINE@ template_cfg_peer2.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-udp-p2/
+
+[transport-udp]
+PORT = 12050
+BROADCAST = NO
+MAX_BPS = 50000000
+BINDTO = 127.0.0.1
+BINDTO6 = ::1
+
+[transport]
+PLUGINS = udp
+
+
diff --git a/src/service/transport/test_transport_api_unix_peer1.conf b/src/service/transport/test_transport_api_unix_peer1.conf
new file mode 100644
index 000000000..005558bcc
--- /dev/null
+++ b/src/service/transport/test_transport_api_unix_peer1.conf
@@ -0,0 +1,10 @@
+@INLINE@ template_cfg_peer1.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-unix-p1/
+
+[transport]
+PLUGINS = unix
+
+[transport-unix]
+PORT = 12120
+
diff --git a/src/service/transport/test_transport_api_unix_peer2.conf b/src/service/transport/test_transport_api_unix_peer2.conf
new file mode 100644
index 000000000..840ed81c7
--- /dev/null
+++ b/src/service/transport/test_transport_api_unix_peer2.conf
@@ -0,0 +1,7 @@
+@INLINE@ template_cfg_peer2.conf
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-unix-p2/
+
+[transport]
+PLUGINS = unix
+
diff --git a/src/service/transport/test_transport_defaults.conf b/src/service/transport/test_transport_defaults.conf
new file mode 100644
index 000000000..03e7addec
--- /dev/null
+++ b/src/service/transport/test_transport_defaults.conf
@@ -0,0 +1,20 @@
+@INLINE@ ../../../contrib/conf/gnunet/no_forcestart.conf
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-tng/
+
+[transport-tcp]
+TIMEOUT = 300 s
+
+[transport]
+# PREFIX = valgrind 
+
+[nat]
+DISABLEV6 = NO
+RETURN_LOCAL_ADDRESSES = YES
+BINDTO = 127.0.0.1
+INTERNAL_ADDRESS = 127.0.0.1
+EXTERNAL_ADDRESS = 127.0.0.1
+
+[transport-udp]
+BROADCAST_RECEIVE = no
diff --git a/src/service/transport/test_transport_distance_vector_circle_topo.conf b/src/service/transport/test_transport_distance_vector_circle_topo.conf
new file mode 100644
index 000000000..e8d694c3a
--- /dev/null
+++ b/src/service/transport/test_transport_distance_vector_circle_topo.conf
@@ -0,0 +1,11 @@
+M:1
+N:3
+X:0
+B:0
+T:libgnunet_test_transport_plugin_cmd_simple_send_dv
+R:1|{tcp_port:0}|{udp_port:1}
+R:2|{tcp_port:0}|{udp_port:1}
+R:3|{tcp_port:0}|{udp_port:1}
+P:1:1|{connect:{P:2:1:udp}}
+P:2:1|{connect:{P:3:1:udp}}
+P:3:1|{connect:{P:1:1:udp}}
diff --git a/src/service/transport/test_transport_distance_vector_inverse_topo.conf b/src/service/transport/test_transport_distance_vector_inverse_topo.conf
new file mode 100644
index 000000000..e062b3e2e
--- /dev/null
+++ b/src/service/transport/test_transport_distance_vector_inverse_topo.conf
@@ -0,0 +1,13 @@
+M:1
+N:4
+X:0
+AC:1
+T:libgnunet_test_transport_plugin_cmd_simple_send_dv
+R:1|{tcp_port:1}|{udp_port:0}
+R:2|{tcp_port:1}|{udp_port:0}
+R:3|{tcp_port:1}|{udp_port:0}
+R:4|{tcp_port:1}|{udp_port:0}
+P:1:1|{connect:{P:2:1:tcp}}|{AC:2}
+P:2:1|{connect:{P:3:1:tcp}}|{AC:2}
+P:3:1|{connect:{P:4:1:tcp}}|{AC:2}
+P:4:1|{AC:3}
\ No newline at end of file
diff --git a/src/service/transport/test_transport_distance_vector_topo.conf b/src/service/transport/test_transport_distance_vector_topo.conf
new file mode 100644
index 000000000..ead3e0a0a
--- /dev/null
+++ b/src/service/transport/test_transport_distance_vector_topo.conf
@@ -0,0 +1,8 @@
+M:2
+N:2
+X:0
+T:libgnunet_test_transport_plugin_cmd_simple_send_dv
+R:1|{tcp_port:1}|{udp_port:0}
+R:2|{tcp_port:1}|{udp_port:0}
+P:1:1|{connect:{P:2:1:tcp}}
+P:2:1|{connect:{P:1:1:tcp}}
diff --git a/src/service/transport/test_transport_just_run_topo.conf b/src/service/transport/test_transport_just_run_topo.conf
new file mode 100644
index 000000000..d27a2fc77
--- /dev/null
+++ b/src/service/transport/test_transport_just_run_topo.conf
@@ -0,0 +1,6 @@
+M:2
+N:1
+X:0
+T:libgnunet_test_transport_plugin_cmd_just_run
+P:1:1|{connect:{P:1:2:tcp}|{P:1:2:udp}}
+P:1:2|{connect:{P:1:1:tcp}|{P:1:1:udp}}
\ No newline at end of file
diff --git a/src/service/transport/test_transport_nat_icmp_tcp.sh b/src/service/transport/test_transport_nat_icmp_tcp.sh
new file mode 100755
index 000000000..41cdde487
--- /dev/null
+++ b/src/service/transport/test_transport_nat_icmp_tcp.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+if ! [ -d "/run/netns" ]; then
+    echo You have to create the directory /run/netns.
+fi
+if [ -f /proc/sys/kernel/unprivileged_userns_clone ]; then
+  if  [ "$(cat /proc/sys/kernel/unprivileged_userns_clone)" != 1 ]; then
+    echo -e "Error during test setup: The kernel parameter kernel.unprivileged_userns_clone has to be set to 1! One has to execute\n\n sysctl kernel.unprivileged_userns_clone=1\n"
+    exit 78
+  fi
+fi
+exec unshare -r -nmU bash -c "mount -t tmpfs --make-rshared tmpfs /run/netns; ./test_transport_start_with_config test_transport_nat_icmp_tcp_topo.conf"
+#sudo valgrind --vgdb=yes --leak-check=full --track-origins=yes --trace-children=yes --trace-children-skip=/usr/bin/awk,/usr/bin/cut,/usr/bin/seq,/sbin/ip/sed/bash ./test_transport_start_with_config test_transport_nat_upnp_topo.conf
diff --git a/src/service/transport/test_transport_nat_icmp_tcp_topo.conf b/src/service/transport/test_transport_nat_icmp_tcp_topo.conf
new file mode 100644
index 000000000..37738c80f
--- /dev/null
+++ b/src/service/transport/test_transport_nat_icmp_tcp_topo.conf
@@ -0,0 +1,7 @@
+M:1
+N:1
+X:1
+T:libgnunet_test_transport_plugin_cmd_nat_upnp
+K:1|{connect:{P:1:1:tcp_natted}}
+R:1|{tcp_port:0}|{udp_port:0}
+P:1:1
\ No newline at end of file
diff --git a/src/service/transport/test_transport_nat_upnp.sh b/src/service/transport/test_transport_nat_upnp.sh
new file mode 100755
index 000000000..df43ef320
--- /dev/null
+++ b/src/service/transport/test_transport_nat_upnp.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+if ! [ -d "/run/netns" ]; then
+    echo You have to create the directory /run/netns.
+fi
+if [ -f /proc/sys/kernel/unprivileged_userns_clone ]; then
+  if  [ "$(cat /proc/sys/kernel/unprivileged_userns_clone)" != 1 ]; then
+    echo -e "Error during test setup: The kernel parameter kernel.unprivileged_userns_clone has to be set to 1! One has to execute\n\n sysctl kernel.unprivileged_userns_clone=1\n"
+    exit 78
+  fi
+fi
+exec unshare -r -nmU bash -c "mount -t tmpfs --make-rshared tmpfs /run/netns; ./test_transport_start_with_config test_transport_nat_upnp_topo.conf"
+#sudo valgrind --vgdb=yes --leak-check=full --track-origins=yes --trace-children=yes --trace-children-skip=/usr/bin/awk,/usr/bin/cut,/usr/bin/seq,/sbin/ip/sed/bash ./test_transport_start_with_config test_transport_nat_upnp_topo.conf
diff --git a/src/service/transport/test_transport_nat_upnp_topo.conf b/src/service/transport/test_transport_nat_upnp_topo.conf
new file mode 100644
index 000000000..e02633d4b
--- /dev/null
+++ b/src/service/transport/test_transport_nat_upnp_topo.conf
@@ -0,0 +1,7 @@
+M:1
+N:1
+X:1
+T:libgnunet_test_transport_plugin_cmd_nat_upnp
+K:1|{connect:{P:1:1:tcp}}
+R:1|{tcp_port:0}|{udp_port:0}|{script:upnp.sh}
+P:1:1|{connect:{K:1:udp}}
\ No newline at end of file
diff --git a/src/service/transport/test_transport_plugin_cmd_just_run.c b/src/service/transport/test_transport_plugin_cmd_just_run.c
new file mode 100644
index 000000000..df7484884
--- /dev/null
+++ b/src/service/transport/test_transport_plugin_cmd_just_run.c
@@ -0,0 +1,494 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testbed/plugin_cmd_simple_send.c
+ * @brief a plugin to provide the API for running test cases.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_testing_barrier.h"
+#include "gnunet_testing_netjail_lib.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_transport_application_service.h"
+#include "transport-testing2.h"
+#include "transport-testing-cmds.h"
+#include "gnunet_testing_barrier.h"
+#include "gnunet_core_service.h"
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
+
+#define BASE_DIR "testdir"
+
+#define TOPOLOGY_CONFIG "test_transport_simple_send_topo.conf"
+
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 600)
+
+#define MAX_RECEIVED 1000
+
+#define MESSAGE_SIZE 65000
+
+static struct GNUNET_TESTING_Command block_script;
+
+static struct GNUNET_TESTING_Command connect_peers;
+
+static struct GNUNET_TESTING_Command local_prepared;
+
+static struct GNUNET_TESTING_Command start_peer;
+
+static struct GNUNET_TESTING_Interpreter *is;
+
+static struct GNUNET_CONTAINER_MultiPeerMap *senders;
+
+struct Sender
+{
+  /**
+   * Number of received messages from sender.
+   */
+  unsigned long long num_received;
+
+  /**
+   * Sample mean time the message traveled.
+   */
+  struct GNUNET_TIME_Relative mean_time;
+
+  /**
+   * Time the first message was send.
+   */
+  struct GNUNET_TIME_Absolute time_first;
+};
+
+/**
+ * Function called to check a message of type GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE being
+ * received.
+ *
+ */
+static int
+check_test (void *cls,
+            const struct
+            GNUNET_TRANSPORT_TESTING_PerformanceTestMessage *message)
+{
+  return GNUNET_OK;
+}
+
+
+struct GNUNET_TESTING_BarrierList*
+get_waiting_for_barriers ()
+{
+  struct GNUNET_TESTING_BarrierList*barriers;
+  struct GNUNET_TESTING_BarrierListEntry *ble;
+
+  barriers = GNUNET_new (struct GNUNET_TESTING_BarrierList);
+  ble = GNUNET_new (struct GNUNET_TESTING_BarrierListEntry);
+  ble->barrier_name = "ready-to-connect";
+  ble->expected_reaches = 1;
+  GNUNET_CONTAINER_DLL_insert (barriers->head,
+                               barriers->tail,
+                               ble);
+
+  ble = GNUNET_new (struct GNUNET_TESTING_BarrierListEntry);
+  ble->barrier_name = "test-case-finished";
+  ble->expected_reaches = 1;
+  GNUNET_CONTAINER_DLL_insert (barriers->head,
+                               barriers->tail,
+                               ble);
+  return barriers;
+}
+
+
+/**
+ * Callback to set the flag indicating all peers started. Will be called via the plugin api.
+ *
+ */
+static void
+all_peers_started ()
+{
+}
+
+
+/**
+ * Function called with the final result of the test.
+ *
+ * @param cls the `struct MainParams`
+ * @param rv #GNUNET_OK if the test passed
+ */
+static void
+handle_result (void *cls,
+               enum GNUNET_GenericReturnValue rv)
+{
+  struct TestState *ts = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Local test exits with status %d\n",
+              rv);
+
+  ts->finished_cb (rv);
+  GNUNET_free (ts->testdir);
+  GNUNET_free (ts->cfgname);
+  GNUNET_TESTING_free_topology (ts->topology);
+  GNUNET_free (ts);
+}
+
+
+/**
+ * Callback from start peer cmd for signaling a peer got connected.
+ *
+ *
+static void *
+notify_connect (struct GNUNET_TESTING_Interpreter *is,
+                const struct GNUNET_PeerIdentity *peer)
+{
+  const struct ConnectPeersState *cps;
+  const struct GNUNET_TESTING_Command *cmd;
+
+  cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                   "connect-peers");
+  GNUNET_TRANSPORT_get_trait_connect_peer_state (cmd,
+                                                 &cps);
+  void *ret = NULL;
+
+  cps->notify_connect (is,
+                       peer);
+  return ret;
+  }*/
+
+
+/**
+ * Callback to set the flag indicating all peers are prepared to finish. Will be called via the plugin api.
+ */
+static void
+all_local_tests_prepared ()
+{
+  const struct GNUNET_TESTING_LocalPreparedState *lfs;
+
+  GNUNET_TESTING_get_trait_local_prepared_state (&local_prepared,
+                                                 &lfs);
+  GNUNET_assert (NULL != &lfs->ac);
+  if (NULL == lfs->ac.cont)
+    GNUNET_TESTING_async_fail ((struct GNUNET_TESTING_AsyncContext *) &lfs->ac);
+  else
+    GNUNET_TESTING_async_finish ((struct
+                                  GNUNET_TESTING_AsyncContext *) &lfs->ac);
+}
+
+
+static void
+child_completed_callback (void *cls,
+                          enum GNUNET_OS_ProcessStatusType type,
+                          long unsigned int exit_code)
+{
+  
+}
+
+
+/**
+ * Function called to check a message being
+ * received.
+ *
+ */
+static int
+check_encrypted (void *cls, struct GNUNET_MessageHeader *header)
+{
+  return GNUNET_OK;
+}
+
+
+static void
+core_receive_continue (struct GNUNET_PeerIdentity *peer)
+{
+  const struct GNUNET_TESTING_StartPeerState *sps;
+
+  GNUNET_TRANSPORT_get_trait_state (&start_peer,
+                                    &sps);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Executing core receive continue\n");
+  
+  GNUNET_TRANSPORT_core_receive_continue (sps->th, peer);
+}
+
+
+/*static void
+handle_core (void *cls, struct GNUNET_MessageHeader *header)
+{
+  struct GNUNET_PeerIdentity *peer = cls;
+
+  core_receive_continue (peer);
+  }*/
+
+
+/**
+ * Function called to handle a message being received.
+ *
+ */
+static void
+handle_encrypted (void *cls, struct GNUNET_MessageHeader *header)
+{
+  struct GNUNET_PeerIdentity *peer = cls;
+
+  core_receive_continue (peer);
+}
+
+
+static void
+handle_ephemeral_key (void *cls, struct GNUNET_MessageHeader *header)
+{
+  struct GNUNET_PeerIdentity *peer = cls;
+
+  core_receive_continue (peer);
+}
+
+
+static void
+handle_ping (void *cls, struct GNUNET_MessageHeader *header)
+{
+  struct GNUNET_PeerIdentity *peer = cls;
+
+  core_receive_continue (peer);
+}
+
+
+static void
+handle_pong (void *cls, struct GNUNET_MessageHeader *header)
+{
+  struct GNUNET_PeerIdentity *peer = cls;
+
+  core_receive_continue (peer);
+}
+
+/**
+ * Function to start a local test case.
+ *
+ * @param write_message Callback to send a message to the master loop.
+ * @param router_ip Global address of the network namespace.
+ * @param node_ip The IP address of the node.
+ * @param m The number of the node in a network namespace.
+ * @param n The number of the network namespace.
+ * @param local_m The number of nodes in a network namespace.
+ * @param topology_data A file name for the file containing the topology configuration, or a string containing
+ *        the topology configuration.
+ * @param read_file If read_file is GNUNET_YES this string is the filename for the topology configuration,
+ *        if read_file is GNUNET_NO the string contains the topology configuration.
+ * @param finish_cb Callback function which writes a message from the helper process running on a netjail
+ *                  node to the master process * signaling that the test case running on the netjail node finished.
+ * @return Returns the struct GNUNET_TESTING_Interpreter of the command loop running on this netjail node.
+ */
+static struct GNUNET_TESTING_Interpreter *
+start_testcase (GNUNET_TESTING_cmd_helper_write_cb write_message,
+                const char *router_ip,
+                const char *node_ip,
+                const char *m,
+                const char *n,
+                const char *local_m,
+                const char *topology_data,
+                unsigned int *read_file,
+                GNUNET_TESTING_cmd_helper_finish_cb finished_cb)
+{
+
+  unsigned int n_int;
+  unsigned int m_int;
+  unsigned int local_m_int;
+  unsigned int num;
+  struct TestState *ts = GNUNET_new (struct TestState);
+  struct GNUNET_TESTING_NetjailTopology *topology;
+  unsigned int sscanf_ret = 0;
+  char **argv = NULL;
+  int argc = 0;
+
+  ts->finished_cb = finished_cb;
+  LOG (GNUNET_ERROR_TYPE_ERROR,
+       "n %s m %s\n",
+       n,
+       m);
+
+  if (GNUNET_YES == *read_file)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "read from file\n");
+    topology = GNUNET_TESTING_get_topo_from_file (topology_data);
+  }
+  else
+    topology = GNUNET_TESTING_get_topo_from_string (topology_data);
+
+  ts->topology = topology;
+
+  errno = 0;
+  sscanf_ret = sscanf (m, "%u", &m_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+  errno = 0;
+  sscanf_ret = sscanf (n, "%u", &n_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+  errno = 0;
+  sscanf_ret = sscanf (local_m, "%u", &local_m_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+
+  if (0 == n_int)
+    num = m_int;
+  else
+    num = (n_int - 1) * local_m_int + m_int + topology->nodes_x;
+
+  block_script = GNUNET_TESTING_cmd_block_until_external_trigger (
+    "block-script");
+  connect_peers = GNUNET_TRANSPORT_cmd_connect_peers ("connect-peers",
+                                                      "start-peer",
+                                                      "system-create",
+                                                      num,
+                                                      topology,
+                                                      0,
+                                                      GNUNET_NO);
+  local_prepared = GNUNET_TESTING_cmd_local_test_prepared (
+    "local-test-prepared",
+    write_message);
+
+
+  GNUNET_asprintf (&ts->cfgname,
+                   "test_transport_api2_tcp_node1.conf");
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "plugin cfgname: %s\n",
+       ts->cfgname);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "node ip: %s\n",
+       node_ip);
+
+  GNUNET_asprintf (&ts->testdir,
+                   "%s%s%s",
+                   BASE_DIR,
+                   m,
+                   n);
+
+  /*struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_fixed_size (ephemeral_key,
+                             GNUNET_MESSAGE_TYPE_CORE_EPHEMERAL_KEY,
+                             struct EphemeralKeyMessage,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (ping,
+                             GNUNET_MESSAGE_TYPE_CORE_PING,
+                             struct PingMessage,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (pong,
+                             GNUNET_MESSAGE_TYPE_CORE_PONG,
+                             struct PongMessage,
+                             NULL),
+    GNUNET_MQ_handler_end ()
+  };*/
+
+  start_peer = GNUNET_TESTING_cmd_start_peer ("start-peer",
+                                                "system-create",
+                                                num,
+                                                node_ip,
+                                                ts->cfgname,
+                                                GNUNET_NO);
+
+  struct GNUNET_TESTING_Command commands[] = {
+    GNUNET_TESTING_cmd_system_create ("system-create",
+                                      ts->testdir),
+    start_peer,
+    GNUNET_TESTING_cmd_barrier_reached ("ready-to-connect-reached",
+                                        "ready-to-connect",
+                                        GNUNET_NO,
+                                        num,
+                                        GNUNET_NO,
+                                        write_message),
+    connect_peers,
+    GNUNET_TESTING_cmd_exec_bash_script ("script",
+                                         "block.sh",
+                                         argv,
+                                         argc,
+                                         &child_completed_callback),
+    block_script,
+    GNUNET_TESTING_cmd_barrier_reached ("test-case-finished-reached",
+                                        "test-case-finished",
+                                        GNUNET_NO,
+                                        num,
+                                        GNUNET_NO,
+                                        write_message),
+    GNUNET_TRANSPORT_cmd_stop_peer ("stop-peer",
+                                    "start-peer"),
+    GNUNET_TESTING_cmd_system_destroy ("system-destroy",
+                                       "system-create"),
+    GNUNET_TESTING_cmd_end ()
+  };
+
+  ts->write_message = write_message;
+
+  is = GNUNET_TESTING_run (commands,
+                           TIMEOUT,
+                           &handle_result,
+                           ts);
+  return is;
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls NULL
+ * @return the exported block API
+ */
+void *
+libgnunet_test_transport_plugin_cmd_just_run_init (void *cls)
+{
+  struct GNUNET_TESTING_PluginFunctions *api;
+
+  GNUNET_log_setup ("simple-send",
+                    "DEBUG",
+                    NULL);
+
+  api = GNUNET_new (struct GNUNET_TESTING_PluginFunctions);
+  api->start_testcase = &start_testcase;
+  api->get_waiting_for_barriers = get_waiting_for_barriers;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls the return value from #libgnunet_test_transport_plugin_just_run_init
+ * @return NULL
+ */
+void *
+libgnunet_test_transport_plugin_cmd_just_run_done (void *cls)
+{
+  struct GNUNET_TESTING_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_cmd_simple_send.c */
diff --git a/src/service/transport/test_transport_plugin_cmd_nat_upnp.c b/src/service/transport/test_transport_plugin_cmd_nat_upnp.c
new file mode 100644
index 000000000..01e3e8b72
--- /dev/null
+++ b/src/service/transport/test_transport_plugin_cmd_nat_upnp.c
@@ -0,0 +1,368 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testbed/plugin_cmd_simple_send.c
+ * @brief a plugin to provide the API for running test cases.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_testing_barrier.h"
+#include "gnunet_testing_netjail_lib.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_transport_application_service.h"
+#include "transport-testing2.h"
+#include "transport-testing-cmds.h"
+#include "gnunet_testing_barrier.h"
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
+
+#define BASE_DIR "testdir"
+
+#define TOPOLOGY_CONFIG "test_transport_simple_send_topo.conf"
+
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 600)
+
+static struct GNUNET_TESTING_Command block_send;
+
+static struct GNUNET_TESTING_Command block_receive;
+
+static struct GNUNET_TESTING_Command connect_peers;
+
+static struct GNUNET_TESTING_Command local_prepared;
+
+static struct GNUNET_TESTING_Interpreter *is;
+
+/**
+ * Function called to check a message of type GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE being
+ * received.
+ *
+ */
+static int
+check_test (void *cls,
+            const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
+{
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function called to handle a message of type GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE
+ * being received.
+ *
+ */
+static void
+handle_test (void *cls,
+             const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
+{
+  struct GNUNET_TESTING_AsyncContext *ac;
+
+  GNUNET_TESTING_get_trait_async_context (&block_receive,
+                                          &ac);
+  GNUNET_assert  (NULL != ac);
+  if (NULL == ac->cont)
+    GNUNET_TESTING_async_fail ((struct GNUNET_TESTING_AsyncContext *) ac);
+  else
+    GNUNET_TESTING_async_finish ((struct GNUNET_TESTING_AsyncContext *) ac);
+}
+
+
+struct GNUNET_TESTING_BarrierList*
+get_waiting_for_barriers ()
+{
+  struct GNUNET_TESTING_BarrierList*barriers;
+  struct GNUNET_TESTING_BarrierListEntry *ble;
+
+  barriers = GNUNET_new (struct GNUNET_TESTING_BarrierList);
+  ble = GNUNET_new (struct GNUNET_TESTING_BarrierListEntry);
+  ble->barrier_name = "ready-to-connect";
+  ble->expected_reaches = 1;
+  GNUNET_CONTAINER_DLL_insert (barriers->head,
+                               barriers->tail,
+                               ble);
+
+  ble = GNUNET_new (struct GNUNET_TESTING_BarrierListEntry);
+  ble->barrier_name = "test-case-finished";
+  ble->expected_reaches = 1;
+  GNUNET_CONTAINER_DLL_insert (barriers->head,
+                               barriers->tail,
+                               ble);
+  return barriers;
+}
+
+
+/**
+ * Function called with the final result of the test.
+ *
+ * @param cls the `struct MainParams`
+ * @param rv #GNUNET_OK if the test passed
+ */
+static void
+handle_result (void *cls,
+               enum GNUNET_GenericReturnValue rv)
+{
+  struct TestState *ts = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Local test exits with status %d\n",
+              rv);
+
+  ts->finished_cb (rv);
+  GNUNET_free (ts->testdir);
+  GNUNET_free (ts->cfgname);
+  GNUNET_TESTING_free_topology (ts->topology);
+  GNUNET_free (ts);
+}
+
+
+/**
+ * Callback from start peer cmd for signaling a peer got connected.
+ *
+ */
+static void *
+notify_connect (struct GNUNET_TESTING_Interpreter *is,
+                const struct GNUNET_PeerIdentity *peer)
+{
+  const struct ConnectPeersState *cps;
+  const struct GNUNET_TESTING_Command *cmd;
+
+  cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                   "connect-peers");
+  GNUNET_TRANSPORT_TESTING_get_trait_connect_peer_state (cmd,
+                                               &cps);
+  void *ret = NULL;
+
+  cps->notify_connect (is,
+                       peer);
+  return ret;
+}
+
+
+/**
+ * Function to start a local test case.
+ *
+ * @param write_message Callback to send a message to the master loop.
+ * @param router_ip Global address of the network namespace.
+ * @param node_ip The IP address of the node.
+ * @param m The number of the node in a network namespace.
+ * @param n The number of the network namespace.
+ * @param local_m The number of nodes in a network namespace.
+ * @param topology_data A file name for the file containing the topology configuration, or a string containing
+ *        the topology configuration.
+ * @param read_file If read_file is GNUNET_YES this string is the filename for the topology configuration,
+ *        if read_file is GNUNET_NO the string contains the topology configuration.
+ * @param finish_cb Callback function which writes a message from the helper process running on a netjail
+ *                  node to the master process * signaling that the test case running on the netjail node finished.
+ * @return Returns the struct GNUNET_TESTING_Interpreter of the command loop running on this netjail node.
+ */
+static struct GNUNET_TESTING_Interpreter *
+start_testcase (GNUNET_TESTING_cmd_helper_write_cb write_message,
+                const char *router_ip,
+                const char *node_ip,
+                const char *m,
+                const char *n,
+                const char *local_m,
+                const char *topology_data,
+                unsigned int *read_file,
+                GNUNET_TESTING_cmd_helper_finish_cb finished_cb)
+{
+
+  unsigned int n_int;
+  unsigned int m_int;
+  unsigned int local_m_int;
+  unsigned int num;
+  struct TestState *ts = GNUNET_new (struct TestState);
+  struct GNUNET_TESTING_NetjailTopology *topology;
+  unsigned int sscanf_ret = 0;
+
+  ts->finished_cb = finished_cb;
+  LOG (GNUNET_ERROR_TYPE_ERROR,
+       "n %s m %s\n",
+       n,
+       m);
+
+  if (GNUNET_YES == *read_file)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "read from file\n");
+    topology = GNUNET_TESTING_get_topo_from_file (topology_data);
+  }
+  else
+    topology = GNUNET_TESTING_get_topo_from_string (topology_data);
+
+  ts->topology = topology;
+
+  errno = 0;
+  sscanf_ret = sscanf (m, "%u", &m_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+  errno = 0;
+  sscanf_ret = sscanf (n, "%u", &n_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+  errno = 0;
+  sscanf_ret = sscanf (local_m, "%u", &local_m_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+
+  if (0 == n_int)
+    num = m_int;
+  else
+    num = (n_int - 1) * local_m_int + m_int + topology->nodes_x;
+
+  block_send = GNUNET_TESTING_cmd_block_until_external_trigger (
+    "block");
+  block_receive = GNUNET_TESTING_cmd_block_until_external_trigger (
+    "block-receive");
+  connect_peers = GNUNET_TRANSPORT_cmd_connect_peers ("connect-peers",
+                                                      "start-peer",
+                                                      "system-create",
+                                                      num,
+                                                      topology,
+                                                      0,
+                                                      GNUNET_YES);
+  local_prepared = GNUNET_TESTING_cmd_local_test_prepared (
+    "local-test-prepared",
+    write_message);
+
+
+  GNUNET_asprintf (&ts->cfgname,
+                   "test_transport_api2_tcp_node1.conf");
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "plugin cfgname: %s\n",
+       ts->cfgname);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "node ip: %s\n",
+       node_ip);
+
+  GNUNET_asprintf (&ts->testdir,
+                   "%s%s%s",
+                   BASE_DIR,
+                   m,
+                   n);
+
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_var_size (test,
+                           GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE,
+                           struct GNUNET_TRANSPORT_TESTING_TestMessage,
+                           ts),
+    GNUNET_MQ_handler_end ()
+  };
+
+  struct GNUNET_TESTING_Command commands[] = {
+    GNUNET_TESTING_cmd_system_create ("system-create",
+                                      ts->testdir),
+    GNUNET_TRANSPORT_cmd_start_peer ("start-peer",
+                                     "system-create",
+                                     num,
+                                     node_ip,
+                                     handlers,
+                                     ts->cfgname,
+                                     notify_connect,
+                                     GNUNET_NO),
+    GNUNET_TESTING_cmd_barrier_reached ("ready-to-connect-reached",
+                                        "ready-to-connect",
+                                        GNUNET_NO,
+                                        num,
+                                        GNUNET_NO,
+                                        write_message),
+    connect_peers,
+    GNUNET_TRANSPORT_cmd_send_simple ("send-simple",
+                                      "start-peer",
+                                      "system-create",
+                                      num,
+                                      topology),
+    block_receive,
+    GNUNET_TESTING_cmd_barrier_reached ("test-case-finished-reached",
+                                        "test-case-finished",
+                                        GNUNET_NO,
+                                        num,
+                                        GNUNET_NO,
+                                        write_message),
+    GNUNET_TRANSPORT_cmd_stop_peer ("stop-peer",
+                                    "start-peer"),
+    GNUNET_TESTING_cmd_system_destroy ("system-destroy",
+                                       "system-create"),
+    GNUNET_TESTING_cmd_end ()
+  };
+
+  ts->write_message = write_message;
+
+  is = GNUNET_TESTING_run (commands,
+                           TIMEOUT,
+                           &handle_result,
+                           ts);
+  return is;
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls NULL
+ * @return the exported block API
+ */
+void *
+libgnunet_test_transport_plugin_cmd_nat_upnp_init (void *cls)
+{
+  struct GNUNET_TESTING_PluginFunctions *api;
+
+  GNUNET_log_setup ("simple-send",
+                    "DEBUG",
+                    NULL);
+
+  api = GNUNET_new (struct GNUNET_TESTING_PluginFunctions);
+  api->start_testcase = &start_testcase;
+  api->get_waiting_for_barriers = get_waiting_for_barriers;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls the return value from #libgnunet_test_transport_plugin_nat_upnp_init
+ * @return NULL
+ */
+void *
+libgnunet_test_transport_plugin_cmd_nat_upnp_done (void *cls)
+{
+  struct GNUNET_TESTING_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_cmd_simple_send.c */
diff --git a/src/service/transport/test_transport_plugin_cmd_simple_send.c b/src/service/transport/test_transport_plugin_cmd_simple_send.c
new file mode 100644
index 000000000..efef49826
--- /dev/null
+++ b/src/service/transport/test_transport_plugin_cmd_simple_send.c
@@ -0,0 +1,377 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testbed/plugin_cmd_simple_send.c
+ * @brief a plugin to provide the API for running test cases.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_testing_barrier.h"
+#include "gnunet_testing_netjail_lib.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_transport_application_service.h"
+#include "transport-testing2.h"
+#include "transport-testing-cmds.h"
+#include "gnunet_testing_barrier.h"
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
+
+#define BASE_DIR "testdir"
+
+#define TOPOLOGY_CONFIG "test_transport_simple_send_topo.conf"
+
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 600)
+
+static struct GNUNET_TESTING_Command block_send;
+
+static struct GNUNET_TESTING_Command block_receive;
+
+static struct GNUNET_TESTING_Command connect_peers;
+
+static struct GNUNET_TESTING_Command local_prepared;
+
+static struct GNUNET_TESTING_Interpreter *is;
+
+/**
+ * Function called to check a message of type GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE being
+ * received.
+ *
+ */
+static int
+check_test (void *cls,
+            const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
+{
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function called to handle a message of type GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE
+ * being received.
+ *
+ */
+static void
+handle_test (void *cls,
+             const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
+{
+  struct GNUNET_TESTING_AsyncContext *ac;
+
+  GNUNET_TESTING_get_trait_async_context (&block_receive,
+                                          &ac);
+  GNUNET_assert  (NULL != ac);
+  if (NULL == ac->cont)
+    GNUNET_TESTING_async_fail ((struct GNUNET_TESTING_AsyncContext *) ac);
+  else
+    GNUNET_TESTING_async_finish ((struct GNUNET_TESTING_AsyncContext *) ac);
+}
+
+
+struct GNUNET_TESTING_BarrierList *
+get_waiting_for_barriers ()
+{
+  // No Barrier
+  return GNUNET_new (struct GNUNET_TESTING_BarrierList);
+}
+
+
+/**
+ * Callback to set the flag indicating all peers started. Will be called via the plugin api.
+ *
+ */
+static void
+all_peers_started ()
+{
+  struct GNUNET_TESTING_AsyncContext *ac;
+
+  GNUNET_TESTING_get_trait_async_context (&block_send,
+                                          &ac);
+  GNUNET_assert  (NULL != ac);
+  if (NULL == ac->cont)
+    GNUNET_TESTING_async_fail ((struct GNUNET_TESTING_AsyncContext *) ac);
+  else
+    GNUNET_TESTING_async_finish ((struct GNUNET_TESTING_AsyncContext *) ac);
+}
+
+
+/**
+ * Function called with the final result of the test.
+ *
+ * @param cls the `struct MainParams`
+ * @param rv #GNUNET_OK if the test passed
+ */
+static void
+handle_result (void *cls,
+               enum GNUNET_GenericReturnValue rv)
+{
+  struct TestState *ts = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Local test exits with status %d\n",
+              rv);
+
+  ts->finished_cb (rv);
+  GNUNET_free (ts->testdir);
+  GNUNET_free (ts->cfgname);
+  GNUNET_TESTING_free_topology (ts->topology);
+  GNUNET_free (ts);
+}
+
+
+/**
+ * Callback from start peer cmd for signaling a peer got connected.
+ *
+ */
+static void *
+notify_connect (struct GNUNET_TESTING_Interpreter *is,
+                const struct GNUNET_PeerIdentity *peer)
+{
+  const struct ConnectPeersState *cps;
+  const struct GNUNET_TESTING_Command *cmd;
+
+  cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                   "connect-peers");
+  GNUNET_TRANSPORT_TESTING_get_trait_connect_peer_state (cmd,
+                                               &cps);
+  void *ret = NULL;
+
+  cps->notify_connect (is,
+                       peer);
+  return ret;
+}
+
+
+/**
+ * Callback to set the flag indicating all peers are prepared to finish. Will be called via the plugin api.
+ */
+static void
+all_local_tests_prepared ()
+{
+  const struct GNUNET_TESTING_LocalPreparedState *lfs;
+
+  GNUNET_TESTING_get_trait_local_prepared_state (&local_prepared,
+                                                 &lfs);
+  GNUNET_assert (NULL != &lfs->ac);
+  if (NULL == lfs->ac.cont)
+    GNUNET_TESTING_async_fail ((struct GNUNET_TESTING_AsyncContext *) &lfs->ac);
+  else
+    GNUNET_TESTING_async_finish ((struct
+                                  GNUNET_TESTING_AsyncContext *) &lfs->ac);
+}
+
+
+/**
+ * Function to start a local test case.
+ *
+ * @param write_message Callback to send a message to the master loop.
+ * @param router_ip Global address of the network namespace.
+ * @param node_ip The IP address of the node.
+ * @param m The number of the node in a network namespace.
+ * @param n The number of the network namespace.
+ * @param local_m The number of nodes in a network namespace.
+ */
+static struct GNUNET_TESTING_Interpreter *
+start_testcase (GNUNET_TESTING_cmd_helper_write_cb write_message,
+                const char *router_ip,
+                const char *node_ip,
+                const char *m,
+                const char *n,
+                const char *local_m,
+                const char *topology_data,
+                unsigned int *read_file,
+                GNUNET_TESTING_cmd_helper_finish_cb finished_cb)
+{
+
+  unsigned int n_int;
+  unsigned int m_int;
+  unsigned int local_m_int;
+  unsigned int num;
+  struct TestState *ts = GNUNET_new (struct TestState);
+  struct GNUNET_TESTING_NetjailTopology *topology;
+  unsigned int sscanf_ret = 0;
+
+  ts->finished_cb = finished_cb;
+  LOG (GNUNET_ERROR_TYPE_ERROR,
+       "n %s m %s\n",
+       n,
+       m);
+
+  if (GNUNET_YES == *read_file)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "read from file\n");
+    topology = GNUNET_TESTING_get_topo_from_file (topology_data);
+  }
+  else
+    topology = GNUNET_TESTING_get_topo_from_string (topology_data);
+
+  ts->topology = topology;
+
+  errno = 0;
+  sscanf_ret = sscanf (m, "%u", &m_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+  errno = 0;
+  sscanf_ret = sscanf (n, "%u", &n_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+  errno = 0;
+  sscanf_ret = sscanf (local_m, "%u", &local_m_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+
+  if (0 == n_int)
+    num = m_int;
+  else
+    num = (n_int - 1) * local_m_int + m_int + topology->nodes_x;
+
+  block_send = GNUNET_TESTING_cmd_block_until_external_trigger (
+    "block");
+  block_receive = GNUNET_TESTING_cmd_block_until_external_trigger (
+    "block-receive");
+  connect_peers = GNUNET_TRANSPORT_cmd_connect_peers ("connect-peers",
+                                                      "start-peer",
+                                                      "system-create",
+                                                      num,
+                                                      topology,
+                                                      0,
+                                                      GNUNET_YES);
+  local_prepared = GNUNET_TESTING_cmd_local_test_prepared (
+    "local-test-prepared",
+    write_message);
+
+
+  GNUNET_asprintf (&ts->cfgname,
+                   "test_transport_api2_tcp_node1.conf");
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "plugin cfgname: %s\n",
+       ts->cfgname);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "node ip: %s\n",
+       node_ip);
+
+  GNUNET_asprintf (&ts->testdir,
+                   "%s%s%s",
+                   BASE_DIR,
+                   m,
+                   n);
+
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_var_size (test,
+                           GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE,
+                           struct GNUNET_TRANSPORT_TESTING_TestMessage,
+                           ts),
+    GNUNET_MQ_handler_end ()
+  };
+
+  struct GNUNET_TESTING_Command commands[] = {
+    GNUNET_TESTING_cmd_system_create ("system-create",
+                                      ts->testdir),
+    GNUNET_TRANSPORT_cmd_start_peer ("start-peer",
+                                     "system-create",
+                                     num,
+                                     node_ip,
+                                     handlers,
+                                     ts->cfgname,
+                                     notify_connect,
+                                     GNUNET_NO),
+    GNUNET_TESTING_cmd_send_peer_ready ("send-peer-ready",
+                                        write_message),
+    block_send,
+    connect_peers,
+    GNUNET_TRANSPORT_cmd_send_simple ("send-simple",
+                                      "start-peer",
+                                      "system-create",
+                                      num,
+                                      topology),
+    block_receive,
+    local_prepared,
+    GNUNET_TRANSPORT_cmd_stop_peer ("stop-peer",
+                                    "start-peer"),
+    GNUNET_TESTING_cmd_system_destroy ("system-destroy",
+                                       "system-create"),
+    GNUNET_TESTING_cmd_end ()
+  };
+
+  ts->write_message = write_message;
+
+  is = GNUNET_TESTING_run (commands,
+                           TIMEOUT,
+                           &handle_result,
+                           ts);
+  return is;
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls NULL
+ * @return the exported block API
+ */
+void *
+libgnunet_test_transport_plugin_cmd_simple_send_init (void *cls)
+{
+  struct GNUNET_TESTING_PluginFunctions *api;
+
+  GNUNET_log_setup ("simple-send",
+                    "DEBUG",
+                    NULL);
+
+  api = GNUNET_new (struct GNUNET_TESTING_PluginFunctions);
+  api->start_testcase = &start_testcase;
+  api->all_peers_started = &all_peers_started;
+  api->all_local_tests_prepared = all_local_tests_prepared;
+  api->get_waiting_for_barriers = get_waiting_for_barriers;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls the return value from #libgnunet_test_transport_plugin_block_test_init
+ * @return NULL
+ */
+void *
+libgnunet_test_transport_plugin_cmd_simple_send_done (void *cls)
+{
+  struct GNUNET_TESTING_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_cmd_simple_send.c */
diff --git a/src/service/transport/test_transport_plugin_cmd_simple_send_broadcast.c b/src/service/transport/test_transport_plugin_cmd_simple_send_broadcast.c
new file mode 100644
index 000000000..79b369b18
--- /dev/null
+++ b/src/service/transport/test_transport_plugin_cmd_simple_send_broadcast.c
@@ -0,0 +1,397 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testbed/plugin_cmd_simple_send_broadcast.c
+ * @brief a plugin to provide the API for running test cases.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_transport_application_service.h"
+#include "transport-testing2.h"
+#include "transport-testing-cmds.h"
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
+
+#define BASE_DIR "testdir"
+
+#define TOPOLOGY_CONFIG "test_transport_simple_send_topo.conf"
+
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 600)
+
+static struct GNUNET_TESTING_Command block_send;
+
+static struct GNUNET_TESTING_Command block_receive;
+
+static struct GNUNET_TESTING_Command connect_peers;
+
+static struct GNUNET_TESTING_Command local_prepared;
+
+static struct GNUNET_TESTING_Interpreter *is;
+
+/**
+ * Function called to check a message of type GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE being
+ * received.
+ *
+ */
+static int
+check_test (void *cls,
+            const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
+{
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function called to handle a message of type GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE
+ * being received.
+ *
+ */
+static void
+handle_test (void *cls,
+             const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
+{
+  struct GNUNET_TESTING_AsyncContext *ac;
+
+  GNUNET_TESTING_get_trait_async_context (&block_receive,
+                                          &ac);
+  GNUNET_assert  (NULL != ac);
+  if ((GNUNET_NO == ac->finished) && (NULL == ac->cont))
+    GNUNET_TESTING_async_fail ((struct GNUNET_TESTING_AsyncContext *) ac);
+  else if (GNUNET_NO == ac->finished)
+    GNUNET_TESTING_async_finish ((struct GNUNET_TESTING_AsyncContext *) ac);
+}
+
+
+struct GNUNET_TESTING_BarrierList *
+get_waiting_for_barriers ()
+{
+  // No Barrier
+  return GNUNET_new (struct GNUNET_TESTING_BarrierList);
+}
+
+
+/**
+ * Callback to set the flag indicating all peers started. Will be called via the plugin api.
+ *
+ */
+static void
+all_peers_started ()
+{
+  struct GNUNET_TESTING_AsyncContext *ac;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received message\n");
+  GNUNET_TESTING_get_trait_async_context (&block_send,
+                                          &ac);
+  GNUNET_assert  (NULL != ac);
+  if (NULL == ac->cont)
+    GNUNET_TESTING_async_fail ((struct GNUNET_TESTING_AsyncContext *) ac);
+  else
+    GNUNET_TESTING_async_finish ((struct GNUNET_TESTING_AsyncContext *) ac);
+}
+
+
+/**
+ * Function called with the final result of the test.
+ *
+ * @param cls the `struct MainParams`
+ * @param rv #GNUNET_OK if the test passed
+ */
+static void
+handle_result (void *cls,
+               enum GNUNET_GenericReturnValue rv)
+{
+  struct TestState *ts = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Local test exits with status %d\n",
+              rv);
+  ts->finished_cb (rv);
+  GNUNET_free (ts->testdir);
+  GNUNET_free (ts->cfgname);
+  GNUNET_TESTING_free_topology (ts->topology);
+  GNUNET_free (ts);
+}
+
+
+/**
+ * Callback from start peer cmd for signaling a peer got connected.
+ *
+ */
+static void *
+notify_connect (struct GNUNET_TESTING_Interpreter *is,
+                const struct GNUNET_PeerIdentity *peer)
+{
+  struct GNUNET_TESTING_AsyncContext *ac;
+  void *ret = NULL;
+  const struct GNUNET_TESTING_Command *cmd;
+  struct GNUNET_TESTING_BlockState *bs;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "notify_connect\n");
+  GNUNET_TESTING_get_trait_async_context (&connect_peers,
+                                          &ac);
+  if (NULL != ac->is)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "notify_connect running\n");
+    GNUNET_assert  (NULL != ac);
+    if (NULL == ac->cont)
+      GNUNET_TESTING_async_fail (ac);
+    else
+      GNUNET_TESTING_async_finish (ac);
+  }
+  else
+  {
+    cmd = GNUNET_TESTING_interpreter_lookup_future_command (is,
+                                                            "connect-peers");
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "block state %s\n",
+         cmd->label.value);
+    GNUNET_TESTING_get_trait_block_state (
+      cmd,
+      &bs);
+
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "block state %u\n",
+         bs->asynchronous_finish);
+    bs->asynchronous_finish = GNUNET_YES;
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "block state %u\n",
+         bs->asynchronous_finish);
+  }
+
+  return ret;
+}
+
+
+/**
+ * Callback to set the flag indicating all peers are prepared to finish. Will be called via the plugin api.
+ */
+static void
+all_local_tests_prepared ()
+{
+  const struct GNUNET_TESTING_LocalPreparedState *lfs;
+
+  GNUNET_TESTING_get_trait_local_prepared_state (&local_prepared,
+                                                 &lfs);
+  GNUNET_assert (NULL != &lfs->ac);
+  if (NULL == lfs->ac.cont)
+    GNUNET_TESTING_async_fail ((struct GNUNET_TESTING_AsyncContext *) &lfs->ac);
+  else
+    GNUNET_TESTING_async_finish ((struct
+                                  GNUNET_TESTING_AsyncContext *) &lfs->ac);
+}
+
+
+/**
+ * Function to start a local test case.
+ *
+ * @param write_message Callback to send a message to the master loop.
+ * @param router_ip Global address of the network namespace.
+ * @param node_ip The IP address of the node.
+ * @param m The number of the node in a network namespace.
+ * @param n The number of the network namespace.
+ * @param local_m The number of nodes in a network namespace.
+ */
+static struct GNUNET_TESTING_Interpreter *
+start_testcase (GNUNET_TESTING_cmd_helper_write_cb write_message,
+                const char *router_ip,
+                const char *node_ip,
+                const char *m,
+                const char *n,
+                const char *local_m,
+                const char *topology_data,
+                unsigned int *read_file,
+                GNUNET_TESTING_cmd_helper_finish_cb finished_cb)
+{
+  unsigned int n_int;
+  unsigned int m_int;
+  unsigned int local_m_int;
+  unsigned int num;
+  struct TestState *ts = GNUNET_new (struct TestState);
+  struct GNUNET_TESTING_NetjailTopology *topology;
+  unsigned int sscanf_ret = 0;
+
+  ts->finished_cb = finished_cb;
+  LOG (GNUNET_ERROR_TYPE_ERROR,
+       "n %s m %s\n",
+       n,
+       m);
+
+  if (GNUNET_YES == *read_file)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "read from file\n");
+    topology = GNUNET_TESTING_get_topo_from_file (topology_data);
+  }
+  else
+    topology = GNUNET_TESTING_get_topo_from_string (topology_data);
+
+  ts->topology = topology;
+
+  errno = 0;
+  sscanf_ret = sscanf (m, "%u", &m_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+  errno = 0;
+  sscanf_ret = sscanf (n, "%u", &n_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+  errno = 0;
+  sscanf_ret = sscanf (local_m, "%u", &local_m_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+
+  if (0 == n_int)
+    num = m_int;
+  else
+    num = (n_int - 1) * local_m_int + m_int + topology->nodes_x;
+
+  block_send = GNUNET_TESTING_cmd_block_until_external_trigger ("block");
+  block_receive = GNUNET_TESTING_cmd_block_until_external_trigger (
+    "block-receive");
+  connect_peers = GNUNET_TESTING_cmd_block_until_external_trigger (
+    "connect-peers");
+  local_prepared = GNUNET_TESTING_cmd_local_test_prepared (
+    "local-test-prepared",
+    write_message);
+
+
+  GNUNET_asprintf (&ts->cfgname,
+                   "test_transport_api2_tcp_node1.conf");
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "plugin cfgname: %s\n",
+       ts->cfgname);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "node ip: %s\n",
+       node_ip);
+
+  GNUNET_asprintf (&ts->testdir,
+                   "%s%s%s",
+                   BASE_DIR,
+                   m,
+                   n);
+
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_var_size (test,
+                           GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE,
+                           struct GNUNET_TRANSPORT_TESTING_TestMessage,
+                           ts),
+    GNUNET_MQ_handler_end ()
+  };
+
+  struct GNUNET_TESTING_Command commands[] = {
+    GNUNET_TESTING_cmd_system_create ("system-create",
+                                      ts->testdir),
+    GNUNET_TRANSPORT_cmd_start_peer ("start-peer",
+                                     "system-create",
+                                     num,
+                                     node_ip,
+                                     handlers,
+                                     ts->cfgname,
+                                     notify_connect,
+                                     GNUNET_YES),
+    GNUNET_TESTING_cmd_send_peer_ready ("send-peer-ready",
+                                        write_message),
+    block_send,
+    connect_peers,
+    GNUNET_TRANSPORT_cmd_send_simple ("send-simple",
+                                      "start-peer",
+                                      "system-create",
+                                      num,
+                                      topology),
+    block_receive,
+    local_prepared,
+    GNUNET_TRANSPORT_cmd_stop_peer ("stop-peer",
+                                    "start-peer"),
+    GNUNET_TESTING_cmd_system_destroy ("system-destroy",
+                                       "system-create"),
+    GNUNET_TESTING_cmd_end ()
+  };
+
+  ts->write_message = write_message;
+
+  is = GNUNET_TESTING_run (commands,
+                           TIMEOUT,
+                           &handle_result,
+                           ts);
+  return is;
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls NULL
+ * @return the exported block API
+ */
+void *
+libgnunet_test_transport_plugin_cmd_simple_send_broadcast_init (void *cls)
+{
+  struct GNUNET_TESTING_PluginFunctions *api;
+
+  GNUNET_log_setup ("simple-send",
+                    "DEBUG",
+                    NULL);
+
+  api = GNUNET_new (struct GNUNET_TESTING_PluginFunctions);
+  api->start_testcase = &start_testcase;
+  api->all_peers_started = &all_peers_started;
+  api->all_local_tests_prepared = all_local_tests_prepared;
+  api->get_waiting_for_barriers = get_waiting_for_barriers;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls the return value from #libgnunet_test_transport_plugin_block_test_init
+ * @return NULL
+ */
+void *
+libgnunet_test_transport_plugin_cmd_simple_send_broadcast_done (void *cls)
+{
+  struct GNUNET_TESTING_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_cmd_simple_send_broadcast.c */
diff --git a/src/service/transport/test_transport_plugin_cmd_simple_send_dv.c b/src/service/transport/test_transport_plugin_cmd_simple_send_dv.c
new file mode 100644
index 000000000..b92736eaa
--- /dev/null
+++ b/src/service/transport/test_transport_plugin_cmd_simple_send_dv.c
@@ -0,0 +1,433 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testbed/plugin_cmd_simple_send_broadcast.c
+ * @brief a plugin to provide the API for running test cases.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_testing_barrier.h"
+#include "gnunet_testing_netjail_lib.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_transport_application_service.h"
+#include "transport-testing2.h"
+#include "transport-testing-cmds.h"
+#include "gnunet_testing_barrier.h"
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
+
+#define BASE_DIR "testdir"
+
+#define TOPOLOGY_CONFIG "test_transport_simple_send_topo.conf"
+
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 600)
+
+/**
+   * The number of messages received.
+   */
+static unsigned int number_received;
+
+static struct GNUNET_TESTING_Command block_send;
+
+static struct GNUNET_TESTING_Command block_receive;
+
+static struct GNUNET_TESTING_Command connect_peers;
+
+static struct GNUNET_TESTING_Command local_prepared;
+
+static struct GNUNET_TESTING_Command start_peer;
+
+static struct GNUNET_TESTING_Interpreter *is;
+
+/**
+ * Function called to check a message of type GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE being
+ * received.
+ *
+ */
+static int
+check_test (void *cls,
+            const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
+{
+  GNUNET_assert (NULL != cls);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function called to handle a message of type GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE
+ * being received.
+ *
+ */
+static void
+handle_test (void *cls,
+             const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
+{
+  struct GNUNET_PeerIdentity *peer = cls;
+  struct GNUNET_TESTING_AsyncContext *ac_block;
+  const struct GNUNET_CONTAINER_MultiShortmap *connected_peers_map;
+  unsigned int connected;
+  struct GNUNET_TESTING_BlockState *bs;
+  struct GNUNET_TRANSPORT_CoreHandle *ch;
+  const struct GNUNET_TESTING_StartPeerState *sps;
+
+  GNUNET_TRANSPORT_TESTING_get_trait_state (&start_peer,
+                                            &sps);
+  ch = sps->th;
+  GNUNET_TRANSPORT_TESTING_get_trait_connected_peers_map (&start_peer,
+                                                          &connected_peers_map);
+
+  if (NULL != connected_peers_map)
+  {
+    connected = GNUNET_CONTAINER_multishortmap_size (
+      connected_peers_map);
+
+    number_received++;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received %u test message(s) from %s, %u connected peer(s)\n",
+                number_received,
+                GNUNET_i2s (peer),
+                connected);
+
+    GNUNET_TESTING_get_trait_async_context (&block_receive,
+                                            &ac_block);
+
+    if (connected == number_received)
+    {
+      if (NULL != ac_block->is)
+      {
+        GNUNET_assert  (NULL != ac_block);
+        if (NULL == ac_block->cont)
+          GNUNET_TESTING_async_fail ((struct
+                                      GNUNET_TESTING_AsyncContext *) ac_block);
+        else
+          GNUNET_TESTING_async_finish ((struct
+                                        GNUNET_TESTING_AsyncContext *) ac_block);
+      }
+      else
+      {
+        GNUNET_TESTING_get_trait_block_state (
+          &block_receive,
+          &bs);
+        bs->asynchronous_finish = GNUNET_YES;
+      }
+
+    }
+  }
+  GNUNET_TRANSPORT_core_receive_continue (ch, peer);
+}
+
+
+struct GNUNET_TESTING_BarrierList *
+get_waiting_for_barriers ()
+{
+  // No Barrier
+  return GNUNET_new (struct GNUNET_TESTING_BarrierList);
+}
+
+
+/**
+ * Callback to set the flag indicating all peers started. Will be called via the plugin api.
+ *
+ */
+static void
+all_peers_started ()
+{
+  struct GNUNET_TESTING_AsyncContext *ac;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received message\n");
+  GNUNET_TESTING_get_trait_async_context (&block_send,
+                                          &ac);
+  GNUNET_assert  (NULL != ac);
+  if (NULL == ac->cont)
+    GNUNET_TESTING_async_fail ((struct GNUNET_TESTING_AsyncContext *) ac);
+  else
+    GNUNET_TESTING_async_finish ((struct GNUNET_TESTING_AsyncContext *) ac);
+}
+
+
+/**
+ * Function called with the final result of the test.
+ *
+ * @param cls the `struct MainParams`
+ * @param rv #GNUNET_OK if the test passed
+ */
+static void
+handle_result (void *cls,
+               enum GNUNET_GenericReturnValue rv)
+{
+  struct TestState *ts = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Local test exits with status %d\n",
+              rv);
+  ts->finished_cb (rv);
+  GNUNET_free (ts->testdir);
+  GNUNET_free (ts->cfgname);
+  GNUNET_TESTING_free_topology (ts->topology);
+  GNUNET_free (ts);
+}
+
+
+/**
+ * Callback from start peer cmd for signaling a peer got connected.
+ *
+ */
+static void *
+notify_connect (struct GNUNET_TESTING_Interpreter *is,
+                const struct GNUNET_PeerIdentity *peer)
+{
+  const struct ConnectPeersState *cps;
+  const struct GNUNET_TESTING_Command *cmd;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "notify_connect peer %s\n",
+              GNUNET_i2s (peer));
+  // FIXME: modifying future is a bit unclean, not easy to follow logic;
+  // might be better to when reaching the future command to look into
+  // the past...
+  cmd = GNUNET_TESTING_interpreter_lookup_command_all (is,
+                                                       "connect-peers");
+  // FIXME: check return value!
+  GNUNET_TRANSPORT_TESTING_get_trait_connect_peer_state (cmd,
+                                                         &cps);
+  cps->notify_connect (is,
+                       peer);
+  return NULL;
+}
+
+
+/**
+ * Callback to set the flag indicating all peers are prepared to finish. Will be called via the plugin api.
+ */
+static void
+all_local_tests_prepared ()
+{
+  const struct GNUNET_TESTING_LocalPreparedState *lfs;
+
+  GNUNET_TESTING_get_trait_local_prepared_state (&local_prepared,
+                                                 &lfs);
+  GNUNET_assert (NULL != &lfs->ac);
+  if (NULL == lfs->ac.cont)
+    GNUNET_TESTING_async_fail ((struct GNUNET_TESTING_AsyncContext *) &lfs->ac);
+  else
+    GNUNET_TESTING_async_finish ((struct
+                                  GNUNET_TESTING_AsyncContext *) &lfs->ac);
+}
+
+
+/**
+ * Function to start a local test case.
+ *
+ * @param write_message Callback to send a message to the master loop.
+ * @param router_ip Global address of the network namespace.
+ * @param node_ip The IP address of the node.
+ * @param m The number of the node in a network namespace.
+ * @param n The number of the network namespace.
+ * @param local_m The number of nodes in a network namespace.
+ */
+static struct GNUNET_TESTING_Interpreter *
+start_testcase (GNUNET_TESTING_cmd_helper_write_cb write_message,
+                const char *router_ip,
+                const char *node_ip,
+                const char *m,
+                const char *n,
+                const char *local_m,
+                const char *topology_data,
+                unsigned int *read_file,
+                GNUNET_TESTING_cmd_helper_finish_cb finished_cb)
+{
+  unsigned int n_int;
+  unsigned int m_int;
+  unsigned int local_m_int;
+  unsigned int num;
+  struct TestState *ts = GNUNET_new (struct TestState);
+  struct GNUNET_TESTING_NetjailTopology *topology;
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_var_size (test,
+                           GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE,
+                           struct GNUNET_TRANSPORT_TESTING_TestMessage,
+                           ts),
+    GNUNET_MQ_handler_end ()
+  };
+  unsigned int sscanf_ret = 0;
+
+  ts->finished_cb = finished_cb;
+  LOG (GNUNET_ERROR_TYPE_ERROR,
+       "n %s m %s\n",
+       n,
+       m);
+
+  if (GNUNET_YES == *read_file)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "read from file\n");
+    topology = GNUNET_TESTING_get_topo_from_file (topology_data);
+  }
+  else
+    topology = GNUNET_TESTING_get_topo_from_string (topology_data);
+
+  ts->topology = topology;
+
+  errno = 0;
+  sscanf_ret = sscanf (m, "%u", &m_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+  errno = 0;
+  sscanf_ret = sscanf (n, "%u", &n_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+  errno = 0;
+  sscanf_ret = sscanf (local_m, "%u", &local_m_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+
+  if (0 == n_int)
+    num = m_int;
+  else
+    num = (n_int - 1) * local_m_int + m_int + topology->nodes_x;
+
+  block_send = GNUNET_TESTING_cmd_block_until_external_trigger ("block");
+  block_receive = GNUNET_TESTING_cmd_block_until_external_trigger (
+    "block-receive");
+  connect_peers = GNUNET_TRANSPORT_cmd_connect_peers (
+    "connect-peers",
+    "start-peer",
+    "system-create",
+    num,
+    topology,
+    topology->additional_connects,
+    GNUNET_YES);
+  local_prepared = GNUNET_TESTING_cmd_local_test_prepared (
+    "local-test-prepared",
+    write_message);
+
+
+  GNUNET_asprintf (&ts->cfgname,
+                   "test_transport_api2_tcp_node1.conf");
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "plugin cfgname: %s\n",
+       ts->cfgname);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "node ip: %s\n",
+       node_ip);
+
+  GNUNET_asprintf (&ts->testdir,
+                   "%s%s%s",
+                   BASE_DIR,
+                   m,
+                   n);
+
+  start_peer = GNUNET_TRANSPORT_cmd_start_peer ("start-peer",
+                                                "system-create",
+                                                num,
+                                                node_ip,
+                                                handlers,
+                                                ts->cfgname,
+                                                notify_connect,
+                                                GNUNET_NO);
+  struct GNUNET_TESTING_Command commands[] = {
+    GNUNET_TESTING_cmd_system_create ("system-create",
+                                      ts->testdir),
+    start_peer,
+    GNUNET_TESTING_cmd_send_peer_ready ("send-peer-ready",
+                                        write_message),
+    block_send,
+    connect_peers,
+    GNUNET_TRANSPORT_cmd_send_simple ("send-simple",
+                                      "start-peer",
+                                      "system-create",
+                                      num,
+                                      topology),
+    block_receive,
+    local_prepared,
+    GNUNET_TRANSPORT_cmd_stop_peer ("stop-peer",
+                                    "start-peer"),
+    GNUNET_TESTING_cmd_system_destroy ("system-destroy",
+                                       "system-create"),
+    GNUNET_TESTING_cmd_end ()
+  };
+
+  ts->write_message = write_message;
+
+  is = GNUNET_TESTING_run (commands,
+                           TIMEOUT,
+                           &handle_result,
+                           ts);
+  return is;
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls NULL
+ * @return the exported block API
+ */
+void *
+libgnunet_test_transport_plugin_cmd_simple_send_dv_init (void *cls)
+{
+  struct GNUNET_TESTING_PluginFunctions *api;
+
+  GNUNET_log_setup ("simple-send",
+                    "DEBUG",
+                    NULL);
+
+  api = GNUNET_new (struct GNUNET_TESTING_PluginFunctions);
+  api->start_testcase = &start_testcase;
+  api->all_peers_started = &all_peers_started;
+  api->all_local_tests_prepared = all_local_tests_prepared;
+  api->get_waiting_for_barriers = get_waiting_for_barriers;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls the return value from #libgnunet_test_transport_plugin_block_test_init
+ * @return NULL
+ */
+void *
+libgnunet_test_transport_plugin_cmd_simple_send_dv_done (void *cls)
+{
+  struct GNUNET_TESTING_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_cmd_simple_send_broadcast.c */
diff --git a/src/service/transport/test_transport_plugin_cmd_simple_send_performance.c b/src/service/transport/test_transport_plugin_cmd_simple_send_performance.c
new file mode 100644
index 000000000..fe92e0ad9
--- /dev/null
+++ b/src/service/transport/test_transport_plugin_cmd_simple_send_performance.c
@@ -0,0 +1,478 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testbed/plugin_cmd_simple_send.c
+ * @brief a plugin to provide the API for running test cases.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_transport_application_service.h"
+#include "transport-testing2.h"
+#include "transport-testing-cmds.h"
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
+
+#define BASE_DIR "testdir"
+
+#define TOPOLOGY_CONFIG "test_transport_simple_send_topo.conf"
+
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 600)
+
+#define MAX_RECEIVED 1000
+
+#define MESSAGE_SIZE 65000
+
+static struct GNUNET_TESTING_Command block_send;
+
+static struct GNUNET_TESTING_Command block_receive;
+
+static struct GNUNET_TESTING_Command connect_peers;
+
+static struct GNUNET_TESTING_Command local_prepared;
+
+static struct GNUNET_TESTING_Command start_peer;
+
+static struct GNUNET_TESTING_Interpreter *is;
+
+static struct GNUNET_CONTAINER_MultiPeerMap *senders;
+
+struct Sender
+{
+  /**
+   * Number of received messages from sender.
+   */
+  unsigned long long num_received;
+
+  /**
+   * Sample mean time the message traveled.
+   */
+  struct GNUNET_TIME_Relative mean_time;
+
+  /**
+   * Time the first message was send.
+   */
+  struct GNUNET_TIME_Absolute time_first;
+};
+
+/**
+ * Function called to check a message of type GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE being
+ * received.
+ *
+ */
+static int
+check_test (void *cls,
+            const struct
+            GNUNET_TRANSPORT_TESTING_PerformanceTestMessage *message)
+{
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function called to handle a message of type GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE
+ * being received.
+ *
+ */
+static void
+handle_test (void *cls,
+             const struct
+             GNUNET_TRANSPORT_TESTING_PerformanceTestMessage *message)
+{
+  struct GNUNET_PeerIdentity *peer = cls;
+  struct GNUNET_TESTING_AsyncContext *ac;
+  struct Sender *sender;
+  struct GNUNET_TIME_Absolute time_send;
+  struct GNUNET_TIME_Absolute now;
+  struct GNUNET_TIME_Relative time_traveled;
+  uint32_t num;
+  struct GNUNET_TRANSPORT_CoreHandle *ch;
+  const struct GNUNET_TESTING_StartPeerState *sps;
+
+
+  GNUNET_TRANSPORT_TESTING_get_trait_state (&start_peer,
+                                            &sps);
+  ch = sps->th;
+  num = ntohl (message->num);
+  GNUNET_TESTING_get_trait_async_context (&block_receive,
+                                          &ac);
+  GNUNET_assert  (NULL != ac);
+
+  sender = GNUNET_CONTAINER_multipeermap_get (senders, peer);
+
+  now = GNUNET_TIME_absolute_get ();
+  time_send = GNUNET_TIME_absolute_ntoh (message->time_send);
+
+  time_traveled = GNUNET_TIME_absolute_get_difference (time_send, now);
+
+  if (NULL == sender)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "time traveled init %s\n",
+                GNUNET_i2s (peer));
+    sender = GNUNET_new (struct Sender);
+    sender->time_first = time_send;
+    sender->mean_time = GNUNET_TIME_UNIT_ZERO;
+    GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multipeermap_put (senders,
+                                                                   peer, sender,
+                                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  }
+
+  if (GNUNET_TIME_UNIT_ZERO.rel_value_us == sender->mean_time.rel_value_us)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "time traveld mean zero\n");
+    sender->mean_time = time_traveled;
+  }
+  else
+  {
+    double factor = (double) sender->num_received
+                    / ((double) sender->num_received + 1.0);
+    struct GNUNET_TIME_Relative s1;
+    struct GNUNET_TIME_Relative s2;
+
+    s1 = GNUNET_TIME_relative_multiply (sender->mean_time,
+                                        factor);
+    s2 = GNUNET_TIME_relative_divide (time_traveled,
+                                      sender->num_received + 1);
+    sender->mean_time = GNUNET_TIME_relative_add (s1, s2);
+  }
+
+  sender->num_received++;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "time traveled: %llu\n",
+              (unsigned long long) time_traveled.rel_value_us);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "mean time traveled: %s %llu messages received with message number %u\n",
+              GNUNET_STRINGS_relative_time_to_string (sender->mean_time,
+                                                      false),
+              sender->num_received,
+              num);
+  if (floor (MAX_RECEIVED * (1 - 1.0 / 200)) < sender->num_received && NULL ==
+      ac->cont)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "time traveled failed\n");
+    // GNUNET_TESTING_async_fail ((struct GNUNET_TESTING_AsyncContext *) ac);
+  }
+  else if (floor (MAX_RECEIVED * (1 - 1.0 / 200)) < sender->num_received &&
+           GNUNET_NO == ac->finished)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "time traveled finish\n");
+    GNUNET_TESTING_async_finish ((struct GNUNET_TESTING_AsyncContext *) ac);
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "time traveled end\n");
+  GNUNET_TRANSPORT_core_receive_continue (ch, peer);
+}
+
+
+struct GNUNET_TESTING_BarrierList*
+get_waiting_for_barriers ()
+{
+  struct GNUNET_TESTING_BarrierList*barriers;
+  struct GNUNET_TESTING_BarrierListEntry *ble;
+
+  barriers = GNUNET_new (struct GNUNET_TESTING_BarrierList);
+  ble = GNUNET_new (struct GNUNET_TESTING_BarrierListEntry);
+  ble->barrier_name = "ready-to-connect";
+  ble->expected_reaches = 1;
+  GNUNET_CONTAINER_DLL_insert (barriers->head,
+                               barriers->tail,
+                               ble);
+
+  ble = GNUNET_new (struct GNUNET_TESTING_BarrierListEntry);
+  ble->barrier_name = "test-case-finished";
+  ble->expected_reaches = 1;
+  GNUNET_CONTAINER_DLL_insert (barriers->head,
+                               barriers->tail,
+                               ble);
+  return barriers;
+}
+
+
+/**
+ * Function called with the final result of the test.
+ *
+ * @param cls the `struct MainParams`
+ * @param rv #GNUNET_OK if the test passed
+ */
+static void
+handle_result (void *cls,
+               enum GNUNET_GenericReturnValue rv)
+{
+  struct TestState *ts = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Local test exits with status %d\n",
+              rv);
+
+  ts->finished_cb (rv);
+  GNUNET_free (ts->testdir);
+  GNUNET_free (ts->cfgname);
+  GNUNET_TESTING_free_topology (ts->topology);
+  GNUNET_free (ts);
+}
+
+
+/**
+ * Callback from start peer cmd for signaling a peer got connected.
+ *
+ */
+static void *
+notify_connect (struct GNUNET_TESTING_Interpreter *is,
+                const struct GNUNET_PeerIdentity *peer)
+{
+  const struct ConnectPeersState *cps;
+  const struct GNUNET_TESTING_Command *cmd;
+
+  cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                   "connect-peers");
+  GNUNET_TRANSPORT_TESTING_get_trait_connect_peer_state (cmd,
+                                                         &cps);
+  void *ret = NULL;
+
+  cps->notify_connect (is,
+                       peer);
+  return ret;
+}
+
+
+/**
+ * Function to start a local test case.
+ *
+ * @param write_message Callback to send a message to the master loop.
+ * @param router_ip Global address of the network namespace.
+ * @param node_ip The IP address of the node.
+ * @param m The number of the node in a network namespace.
+ * @param n The number of the network namespace.
+ * @param local_m The number of nodes in a network namespace.
+ * @param topology_data A file name for the file containing the topology configuration, or a string containing
+ *        the topology configuration.
+ * @param read_file If read_file is GNUNET_YES this string is the filename for the topology configuration,
+ *        if read_file is GNUNET_NO the string contains the topology configuration.
+ * @param finish_cb Callback function which writes a message from the helper process running on a netjail
+ *                  node to the master process * signaling that the test case running on the netjail node finished.
+ * @return Returns the struct GNUNET_TESTING_Interpreter of the command loop running on this netjail node.
+ */
+static struct GNUNET_TESTING_Interpreter *
+start_testcase (GNUNET_TESTING_cmd_helper_write_cb write_message,
+                const char *router_ip,
+                const char *node_ip,
+                const char *m,
+                const char *n,
+                const char *local_m,
+                const char *topology_data,
+                unsigned int *read_file,
+                GNUNET_TESTING_cmd_helper_finish_cb finished_cb)
+{
+
+  unsigned int n_int;
+  unsigned int m_int;
+  unsigned int local_m_int;
+  unsigned int num;
+  struct TestState *ts = GNUNET_new (struct TestState);
+  struct GNUNET_TESTING_NetjailTopology *topology;
+  unsigned int sscanf_ret = 0;
+
+  senders = GNUNET_CONTAINER_multipeermap_create (1, GNUNET_NO);
+  ts->finished_cb = finished_cb;
+  LOG (GNUNET_ERROR_TYPE_ERROR,
+       "n %s m %s\n",
+       n,
+       m);
+
+  if (GNUNET_YES == *read_file)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "read from file\n");
+    topology = GNUNET_TESTING_get_topo_from_file (topology_data);
+  }
+  else
+    topology = GNUNET_TESTING_get_topo_from_string (topology_data);
+
+  ts->topology = topology;
+
+  errno = 0;
+  sscanf_ret = sscanf (m, "%u", &m_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+  errno = 0;
+  sscanf_ret = sscanf (n, "%u", &n_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+  errno = 0;
+  sscanf_ret = sscanf (local_m, "%u", &local_m_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+
+  if (0 == n_int)
+    num = m_int;
+  else
+    num = (n_int - 1) * local_m_int + m_int + topology->nodes_x;
+
+  block_send = GNUNET_TESTING_cmd_block_until_external_trigger (
+    "block");
+  block_receive = GNUNET_TESTING_cmd_block_until_external_trigger (
+    "block-receive");
+  connect_peers = GNUNET_TRANSPORT_cmd_connect_peers ("connect-peers",
+                                                      "start-peer",
+                                                      "system-create",
+                                                      num,
+                                                      topology,
+                                                      0,
+                                                      GNUNET_YES);
+  local_prepared = GNUNET_TESTING_cmd_local_test_prepared (
+    "local-test-prepared",
+    write_message);
+
+
+  GNUNET_asprintf (&ts->cfgname,
+                   "test_transport_api2_tcp_node1.conf");
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "plugin cfgname: %s\n",
+       ts->cfgname);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "node ip: %s\n",
+       node_ip);
+
+  GNUNET_asprintf (&ts->testdir,
+                   "%s%s%s",
+                   BASE_DIR,
+                   m,
+                   n);
+
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_var_size (test,
+                           GNUNET_TRANSPORT_TESTING_SIMPLE_PERFORMANCE_MTYPE,
+                           struct
+                           GNUNET_TRANSPORT_TESTING_PerformanceTestMessage,
+                           ts),
+    GNUNET_MQ_handler_end ()
+  };
+
+  start_peer = GNUNET_TRANSPORT_cmd_start_peer ("start-peer",
+                                                "system-create",
+                                                num,
+                                                node_ip,
+                                                handlers,
+                                                ts->cfgname,
+                                                notify_connect,
+                                                GNUNET_NO);
+
+  struct GNUNET_TESTING_Command commands[] = {
+    GNUNET_TESTING_cmd_system_create ("system-create",
+                                      ts->testdir),
+    start_peer,
+    GNUNET_TESTING_cmd_barrier_reached ("ready-to-connect-reached",
+                                        "ready-to-connect",
+                                        GNUNET_NO,
+                                        num,
+                                        GNUNET_NO,
+                                        write_message),
+    connect_peers,
+    GNUNET_TRANSPORT_cmd_send_simple_performance ("send-simple",
+                                                  "start-peer",
+                                                  "system-create",
+                                                  num,
+                                                  MESSAGE_SIZE,
+                                                  MAX_RECEIVED,
+                                                  topology),
+    block_receive,
+    GNUNET_TESTING_cmd_barrier_reached ("test-case-finished-reached",
+                                        "test-case-finished",
+                                        GNUNET_NO,
+                                        num,
+                                        GNUNET_NO,
+                                        write_message),
+    GNUNET_TRANSPORT_cmd_stop_peer ("stop-peer",
+                                    "start-peer"),
+    GNUNET_TESTING_cmd_system_destroy ("system-destroy",
+                                       "system-create"),
+    GNUNET_TESTING_cmd_end ()
+  };
+
+  ts->write_message = write_message;
+
+  is = GNUNET_TESTING_run (commands,
+                           TIMEOUT,
+                           &handle_result,
+                           ts);
+  return is;
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls NULL
+ * @return the exported block API
+ */
+void *
+libgnunet_test_transport_plugin_cmd_simple_send_performance_init (void *cls)
+{
+  struct GNUNET_TESTING_PluginFunctions *api;
+
+  GNUNET_log_setup ("simple-send",
+                    "DEBUG",
+                    NULL);
+
+  api = GNUNET_new (struct GNUNET_TESTING_PluginFunctions);
+  api->start_testcase = &start_testcase;
+  api->get_waiting_for_barriers = get_waiting_for_barriers;
+  return api;
+}
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls the return value from #libgnunet_test_transport_plugin_simple_send_performance_init
+ * @return NULL
+ */
+void *
+libgnunet_test_transport_plugin_cmd_simple_send_performance_done (void *cls)
+{
+  struct GNUNET_TESTING_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_cmd_simple_send.c */
diff --git a/src/service/transport/test_transport_plugin_cmd_udp_backchannel.c b/src/service/transport/test_transport_plugin_cmd_udp_backchannel.c
new file mode 100644
index 000000000..7e67d6fad
--- /dev/null
+++ b/src/service/transport/test_transport_plugin_cmd_udp_backchannel.c
@@ -0,0 +1,364 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testbed/plugin_cmd_simple_send.c
+ * @brief a plugin to provide the API for running test cases.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_testing_barrier.h"
+#include "gnunet_testing_netjail_lib.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_transport_application_service.h"
+#include "transport-testing2.h"
+#include "transport-testing-cmds.h"
+#include "gnunet_testing_barrier.h"
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind, ...) GNUNET_log_from (kind, "udp-backchannel", __VA_ARGS__)
+
+#define BASE_DIR "testdir"
+
+#define TOPOLOGY_CONFIG "test_transport_udp_backchannel_topo.conf"
+
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 600)
+
+static struct GNUNET_TESTING_Command block_send;
+
+static struct GNUNET_TESTING_Command connect_peers;
+
+static struct GNUNET_TESTING_Command local_prepared;
+
+static struct GNUNET_TESTING_Interpreter *is;
+
+
+/**
+ * Function called to check a message of type GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE being
+ * received.
+ *
+ */
+static int
+check_test (void *cls,
+            const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
+{
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function called to handle a message of type GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE
+ * being received.
+ *
+ */
+static void
+handle_test (void *cls,
+             const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
+{
+  // struct GNUNET_TESTING_AsyncContext *ac;
+
+  /*GNUNET_TESTING_get_trait_async_context (&block_receive,
+                                          &ac);
+  if ((NULL == ac) || (NULL == ac->cont))
+    GNUNET_TESTING_async_fail (ac);
+  else
+    GNUNET_TESTING_async_finish (ac);*/
+}
+
+
+struct GNUNET_TESTING_BarrierList *
+get_waiting_for_barriers ()
+{
+  // No Barrier
+  return GNUNET_new (struct GNUNET_TESTING_BarrierList);
+}
+
+
+/**
+ * Callback to set the flag indicating all peers started. Will be called via the plugin api.
+ *
+ */
+static void
+all_peers_started ()
+{
+  struct GNUNET_TESTING_AsyncContext *ac;
+
+  GNUNET_TESTING_get_trait_async_context (&block_send,
+                                          &ac);
+  GNUNET_assert  (NULL != ac);
+  if ((NULL == ac->cont))
+    GNUNET_TESTING_async_fail ((struct GNUNET_TESTING_AsyncContext *) ac);
+  else
+    GNUNET_TESTING_async_finish ((struct GNUNET_TESTING_AsyncContext *) ac);
+}
+
+
+/**
+* Function called with the final result of the test.
+*
+* @param cls the `struct MainParams`
+* @param rv #GNUNET_OK if the test passed
+*/
+static void
+handle_result (void *cls,
+               enum GNUNET_GenericReturnValue rv)
+{
+  struct TestState *ts = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Local test exits with status %d\n",
+              rv);
+
+  ts->finished_cb (rv);
+  GNUNET_free (ts->testdir);
+  GNUNET_free (ts->cfgname);
+  GNUNET_TESTING_free_topology (ts->topology);
+  GNUNET_free (ts);
+}
+
+
+/**
+ * Callback from start peer cmd for signaling a peer got connected.
+ *
+ */
+static void *
+notify_connect (struct GNUNET_TESTING_Interpreter *is,
+                const struct GNUNET_PeerIdentity *peer)
+{
+  const struct ConnectPeersState *cps;
+
+  GNUNET_TRANSPORT_TESTING_get_trait_connect_peer_state (&connect_peers,
+                                                         &cps);
+  void *ret = NULL;
+
+  cps->notify_connect (is,
+                       peer);
+  return ret;
+}
+
+
+/**
+ * Callback to set the flag indicating all peers are prepared to finish. Will be called via the plugin api.
+ */
+static void
+all_local_tests_prepared ()
+{
+  const struct GNUNET_TESTING_LocalPreparedState *lfs;
+
+  GNUNET_TESTING_get_trait_local_prepared_state (&local_prepared,
+                                                 &lfs);
+  GNUNET_assert (NULL != &lfs->ac);
+  if (NULL == lfs->ac.cont)
+    GNUNET_TESTING_async_fail ((struct GNUNET_TESTING_AsyncContext *) &lfs->ac);
+  else
+    GNUNET_TESTING_async_finish ((struct
+                                  GNUNET_TESTING_AsyncContext *) &lfs->ac);
+}
+
+
+/**
+ * Entry point for the plugin.
+ *
+ * @param cls NULL
+ * @return the exported block API
+ */
+void *
+libgnunet_test_transport_plugin_cmd_udp_backchannel_init (void *cls)
+{
+  struct GNUNET_TESTING_PluginFunctions *api;
+
+  unsigned int n_int;
+  unsigned int m_int;
+  unsigned int local_m_int;
+  unsigned int num;
+  struct TestState *ts = GNUNET_new (struct TestState);
+  struct GNUNET_TESTING_NetjailTopology *topology;
+  unsigned int sscanf_ret = 0;
+
+  ts->finished_cb = finished_cb;
+  LOG (GNUNET_ERROR_TYPE_ERROR,
+       "n %s m %s\n",
+       n,
+       m);
+
+  if (GNUNET_YES == *read_file)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "read from file\n");
+    topology = GNUNET_TESTING_get_topo_from_file (topology_data);
+  }
+  else
+    topology = GNUNET_TESTING_get_topo_from_string (topology_data);
+
+  ts->topology = topology;
+
+  errno = 0;
+  sscanf_ret = sscanf (m, "%u", &m_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+  errno = 0;
+  sscanf_ret = sscanf (n, "%u", &n_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+  errno = 0;
+  sscanf_ret = sscanf (local_m, "%u", &local_m_int);
+  if (errno != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
+  }
+  GNUNET_assert (0 < sscanf_ret);
+
+
+  if (0 == n_int)
+    num = m_int;
+  else
+    num = (n_int - 1) * local_m_int + m_int + topology->nodes_x;
+
+  block_send = GNUNET_TESTING_cmd_block_until_external_trigger (
+    "block");
+  connect_peers = GNUNET_TRANSPORT_cmd_connect_peers ("connect-peers",
+                                                      "start-peer",
+                                                      "system-create",
+                                                      num,
+                                                      topology,
+                                                      0,
+                                                      GNUNET_YES);
+  local_prepared = GNUNET_TESTING_cmd_local_test_prepared (
+    "local-test-prepared",
+    write_message);
+
+  GNUNET_asprintf (&ts->cfgname,
+                   "test_transport_api2_tcp_node1.conf");
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "plugin cfgname: %s\n",
+       ts->cfgname);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "node ip: %s\n",
+       node_ip);
+
+  GNUNET_asprintf (&ts->testdir,
+                   "%s%s%s",
+                   BASE_DIR,
+                   m,
+                   n);
+
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_var_size (test,
+                           GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE,
+                           struct GNUNET_TRANSPORT_TESTING_TestMessage,
+                           NULL),
+    GNUNET_MQ_handler_end ()
+  };
+
+  struct GNUNET_TESTING_Command commands[] = {
+    GNUNET_TESTING_cmd_system_create ("system-create",
+                                      ts->testdir),
+    GNUNET_TRANSPORT_cmd_start_peer ("start-peer",
+                                     "system-create",
+                                     num,
+                                     node_ip,
+                                     handlers,
+                                     ts->cfgname,
+                                     notify_connect,
+                                     GNUNET_NO),
+    GNUNET_TESTING_cmd_send_peer_ready ("send-peer-ready",
+                                        write_message),
+    block_send,
+    connect_peers,
+    GNUNET_TRANSPORT_cmd_backchannel_check ("backchannel-check",
+                                            "start-peer",
+                                            "system-create",
+                                            num,
+                                            m_int,
+                                            n_int,
+                                            topology),
+    local_prepared,
+    GNUNET_TRANSPORT_cmd_stop_peer ("stop-peer",
+                                    "start-peer"),
+    GNUNET_TESTING_cmd_system_destroy ("system-destroy",
+                                       "system-create"),
+    GNUNET_TESTING_cmd_end ()
+  };
+
+  return GNUNET_TESTING_make_plugin (commands);
+}
+
+
+GNUNET_TESTING_MAKE_PLUGIN (
+  libgnunet,
+  udp_backchannel,
+  GNUNET_TESTING_cmd_system_create ("system-create",
+                                    ts->testdir),
+  GNUNET_TRANSPORT_cmd_start_peer ("start-peer",
+                                   "system-create",
+                                   num,
+                                   node_ip,
+                                   handlers,
+                                   ts->cfgname,
+                                   notify_connect,
+                                   GNUNET_NO),
+  GNUNET_TESTING_cmd_send_peer_ready (
+    "send-peer-ready",
+    write_message),
+  block_send,
+  connect_peers,
+  GNUNET_TRANSPORT_cmd_backchannel_check (
+    "backchannel-check",
+    "start-peer",
+    "system-create",
+    num,
+    m_int,
+    n_int,
+    topology),
+  local_prepared,
+  GNUNET_TRANSPORT_cmd_stop_peer ("stop-peer",
+                                  "start-peer"),
+  GNUNET_TESTING_cmd_system_destroy ("system-destroy",
+                                     "system-create")
+  );
+
+
+/**
+ * Exit point from the plugin.
+ *
+ * @param cls the return value from #libgnunet_test_transport_plugin_block_test_init
+ * @return NULL
+ */
+void *
+libgnunet_test_transport_plugin_cmd_udp_backchannel_done (void *cls)
+{
+  struct GNUNET_TESTING_PluginFunctions *api = cls;
+
+  GNUNET_free (api);
+  return NULL;
+}
+
+
+/* end of plugin_cmd_simple_send.c */
diff --git a/src/service/transport/test_transport_simple_send.sh b/src/service/transport/test_transport_simple_send.sh
new file mode 100755
index 000000000..af7515753
--- /dev/null
+++ b/src/service/transport/test_transport_simple_send.sh
@@ -0,0 +1,4 @@
+#!/bin/bash
+exec netjail_test_master.sh ./test_transport_start_with_config test_transport_simple_send_topo.conf
+
+# exec netjail_test_master.sh gnunet-testing-netjail-launcher test_transport_simple_send_topo.conf
diff --git a/src/service/transport/test_transport_simple_send_broadcast.sh b/src/service/transport/test_transport_simple_send_broadcast.sh
new file mode 100755
index 000000000..a4801bf70
--- /dev/null
+++ b/src/service/transport/test_transport_simple_send_broadcast.sh
@@ -0,0 +1,11 @@
+#!/bin/bash
+if ! [ -d "/run/netns" ]; then
+    echo You have to create the directory /run/netns.
+fi
+if [ -f /proc/sys/kernel/unprivileged_userns_clone ]; then
+  if  [ "$(cat /proc/sys/kernel/unprivileged_userns_clone)" != 1 ]; then
+    echo -e "Error during test setup: The kernel parameter kernel.unprivileged_userns_clone has to be set to 1! One has to execute\n\n sysctl kernel.unprivileged_userns_clone=1\n"
+    exit 78
+  fi
+fi
+exec unshare -r -nmU bash -c "mount -t tmpfs --make-rshared tmpfs /run/netns; ./test_transport_start_with_config test_transport_simple_send_broadcast_topo.conf"
diff --git a/src/service/transport/test_transport_simple_send_broadcast_topo.conf b/src/service/transport/test_transport_simple_send_broadcast_topo.conf
new file mode 100644
index 000000000..aa4964f81
--- /dev/null
+++ b/src/service/transport/test_transport_simple_send_broadcast_topo.conf
@@ -0,0 +1,4 @@
+M:2
+N:1
+X:0
+T:libgnunet_test_transport_plugin_cmd_simple_send_broadcast
\ No newline at end of file
diff --git a/src/service/transport/test_transport_simple_send_dv_circle.sh b/src/service/transport/test_transport_simple_send_dv_circle.sh
new file mode 100755
index 000000000..bd5f00abe
--- /dev/null
+++ b/src/service/transport/test_transport_simple_send_dv_circle.sh
@@ -0,0 +1,11 @@
+#!/bin/bash
+if ! [ -d "/run/netns" ]; then
+    echo You have to create the directory /run/netns.
+fi
+if [ -f /proc/sys/kernel/unprivileged_userns_clone ]; then
+  if  [ "$(cat /proc/sys/kernel/unprivileged_userns_clone)" != 1 ]; then
+    echo -e "Error during test setup: The kernel parameter kernel.unprivileged_userns_clone has to be set to 1! One has to execute\n\n sysctl kernel.unprivileged_userns_clone=1\n"
+    exit 78
+  fi
+fi
+exec unshare -r -nmU bash -c "mount -t tmpfs --make-rshared tmpfs /run/netns; ./test_transport_start_with_config test_transport_distance_vector_circle_topo.conf"
diff --git a/src/service/transport/test_transport_simple_send_dv_inverse.sh b/src/service/transport/test_transport_simple_send_dv_inverse.sh
new file mode 100755
index 000000000..cf7b863a0
--- /dev/null
+++ b/src/service/transport/test_transport_simple_send_dv_inverse.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+if ! [ -d "/run/netns" ]; then
+    echo You have to create the directory /run/netns.
+fi
+if [ -f /proc/sys/kernel/unprivileged_userns_clone ]; then
+  if  [ "$(cat /proc/sys/kernel/unprivileged_userns_clone)" != 1 ]; then
+    echo -e "Error during test setup: The kernel parameter kernel.unprivileged_userns_clone has to be set to 1! One has to execute\n\n sysctl kernel.unprivileged_userns_clone=1\n"
+    exit 78
+  fi
+fi
+# exec unshare -r -nmU bash -c "mount -t tmpfs --make-rshared tmpfs /run/netns; valgrind --leak-check=full --track-origins=yes --trace-children=yes --trace-children-skip=/usr/bin/awk,/usr/bin/cut,/usr/bin/seq,/sbin/ip/sed/bash  ./test_transport_start_with_config test_transport_distance_vector_inverse_topo.conf"
+exec unshare -r -nmU bash -c "mount -t tmpfs --make-rshared tmpfs /run/netns; ./test_transport_start_with_config test_transport_distance_vector_inverse_topo.conf"
diff --git a/src/service/transport/test_transport_simple_send_performance.sh b/src/service/transport/test_transport_simple_send_performance.sh
new file mode 100755
index 000000000..12798c2f0
--- /dev/null
+++ b/src/service/transport/test_transport_simple_send_performance.sh
@@ -0,0 +1,11 @@
+#!/bin/bash
+if ! [ -d "/run/netns" ]; then
+    echo You have to create the directory /run/netns.
+fi
+if [ -f /proc/sys/kernel/unprivileged_userns_clone ]; then
+  if  [ "$(cat /proc/sys/kernel/unprivileged_userns_clone)" != 1 ]; then
+    echo -e "Error during test setup: The kernel parameter kernel.unprivileged_userns_clone has to be set to 1! One has to execute\n\n sysctl kernel.unprivileged_userns_clone=1\n"
+    exit 78
+  fi
+fi
+exec unshare -r -nmU bash -c "mount -t tmpfs --make-rshared tmpfs /run/netns; ./test_transport_start_with_config test_transport_simple_send_performance_topo.conf"
diff --git a/src/service/transport/test_transport_simple_send_performance_topo.conf b/src/service/transport/test_transport_simple_send_performance_topo.conf
new file mode 100644
index 000000000..9f39cd9bc
--- /dev/null
+++ b/src/service/transport/test_transport_simple_send_performance_topo.conf
@@ -0,0 +1,6 @@
+M:2
+N:1
+X:0
+T:libgnunet_test_transport_plugin_cmd_simple_send_performance
+P:1:1|{connect:{P:1:2:tcp}|{P:1:2:udp}}
+P:1:2|{connect:{P:1:1:tcp}|{P:1:1:udp}}
\ No newline at end of file
diff --git a/src/service/transport/test_transport_simple_send_string.sh b/src/service/transport/test_transport_simple_send_string.sh
new file mode 100755
index 000000000..211abb494
--- /dev/null
+++ b/src/service/transport/test_transport_simple_send_string.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+string=$(cat << EOF
+M:2
+N:1
+X:0
+T:libgnunet_test_transport_plugin_cmd_simple_send
+P:1:1|{connect:{P:1:2:tcp}}
+P:1:2|{connect:{P:1:1:tcp}}
+EOF
+      )
+if ! [ -d "/run/netns" ]; then
+    echo You have to create the directory /run/netns.
+fi
+if [ -f /proc/sys/kernel/unprivileged_userns_clone ]; then
+  if  [ "$(cat /proc/sys/kernel/unprivileged_userns_clone)" != 1 ]; then
+    echo -e "Error during test setup: The kernel parameter kernel.unprivileged_userns_clone has to be set to 1! One has to execute\n\n sysctl kernel.unprivileged_userns_clone=1\n"
+    exit 78
+  fi
+fi
+
+exec unshare -r -nmU bash -c "mount -t tmpfs --make-rshared tmpfs /run/netns; ./test_transport_start_with_config -s '$string'"
diff --git a/src/service/transport/test_transport_simple_send_topo.conf b/src/service/transport/test_transport_simple_send_topo.conf
new file mode 100644
index 000000000..2c16201f5
--- /dev/null
+++ b/src/service/transport/test_transport_simple_send_topo.conf
@@ -0,0 +1,6 @@
+M:2
+N:1
+X:0
+T:libgnunet_test_transport_plugin_cmd_simple_send
+P:1:1|{connect:{P:1:2:tcp}}
+P:1:2|{connect:{P:1:1:tcp}}
\ No newline at end of file
diff --git a/src/service/transport/test_transport_start_testcase.sh b/src/service/transport/test_transport_start_testcase.sh
new file mode 100755
index 000000000..ad9832fb8
--- /dev/null
+++ b/src/service/transport/test_transport_start_testcase.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+#read -p "Test case configuration to use:" conf
+#if ! [ -d "/run/netns" ]; then
+#    echo You have to create the directory /run/netns.
+#fi
+#if [ -f /proc/sys/kernel/unprivileged_userns_clone ]; then
+#  if  [ "$(cat /proc/sys/kernel/unprivileged_userns_clone)" != 1 ]; then
+#    echo -e "Error during test setup: The kernel parameter kernel.unprivileged_userns_clone has to be set to 1! One has to execute\n\n sysctl kernel.unprivileged_userns_clone=1\n"
+#    exit 78
+#  fi
+#fi
+#exec unshare -r -nmU bash -c "mount -t tmpfs --make-rshared tmpfs /run/netns; ./test_transport_start_with_config $conf"
diff --git a/src/service/transport/test_transport_start_with_config.c b/src/service/transport/test_transport_start_with_config.c
new file mode 100644
index 000000000..2c00dde8a
--- /dev/null
+++ b/src/service/transport/test_transport_start_with_config.c
@@ -0,0 +1,120 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file transport/test_transport_start_with_config.c
+ * @brief Generic program to start testcases in an configurable topology.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_util_lib.h"
+
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 600)
+
+
+int
+main (int argc,
+      char *const *argv)
+{
+  char *topology_data;
+  char *topology_data_script;
+  struct GNUNET_TESTING_NetjailTopology *topology;
+  unsigned int read_file = GNUNET_YES;
+  int ret;
+  char *rest = NULL;
+  char *token;
+  size_t single_line_len;
+  size_t data_len;
+
+  GNUNET_log_setup ("test-netjail",
+                    "INFO",
+                    NULL);
+
+  if (0 == strcmp ("-s", argv[1]))
+  {
+    data_len = strlen (argv[2]);
+    topology_data = GNUNET_malloc (data_len);
+    topology_data_script = GNUNET_malloc (data_len);
+    token = strtok_r (argv[2], "\n", &rest);
+    while (NULL != token)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "token1 %s\n",
+                  token);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "token2 %s\n",
+                  token);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "topology_data %s\n",
+                  topology_data);
+      strcat (topology_data_script, token);
+      strcat (topology_data_script, " ");
+      strcat (topology_data, token);
+      strcat (topology_data, "\n");
+      token = strtok_r (NULL, "\n", &rest);
+    }
+    single_line_len = strlen (topology_data);
+    topology_data_script [single_line_len - 1] = '\0';
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "read from string\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "topology_data %s\n",
+                topology_data);
+    read_file = GNUNET_NO;
+    topology = GNUNET_TESTING_get_topo_from_string (topology_data);
+  }
+  else
+  {
+    topology_data = argv[1];
+    topology_data_script = argv[1];
+    topology = GNUNET_TESTING_get_topo_from_file (topology_data);
+  }
+
+  struct GNUNET_TESTING_Command commands[] = {
+    GNUNET_TESTING_cmd_netjail_start ("netjail-start",
+                                      topology_data_script,
+                                      &read_file),
+    GNUNET_TESTING_cmd_netjail_start_cmds_helper ("netjail-start-testbed",
+                                                  topology,
+                                                  &read_file,
+                                                  topology_data_script,
+                                                  TIMEOUT),
+    GNUNET_TESTING_cmd_stop_cmds_helper ("stop-testbed",
+                                         "netjail-start-testbed",
+                                         topology),
+    GNUNET_TESTING_cmd_netjail_stop ("netjail-stop",
+                                     topology_data_script,
+                                     &read_file),
+    GNUNET_TESTING_cmd_end ()
+  };
+
+  ret = GNUNET_TESTING_main (commands,
+                             TIMEOUT);
+
+  if (0 == strcmp ("-s", argv[1]))
+  {
+    GNUNET_free (topology_data_script);
+    GNUNET_free (topology_data);
+  }
+  GNUNET_TESTING_free_topology (topology);
+
+  return ret;
+}
diff --git a/src/service/transport/test_transport_test_transport_address_switch_tcp_peer1.conf b/src/service/transport/test_transport_test_transport_address_switch_tcp_peer1.conf
new file mode 100644
index 000000000..920e8d199
--- /dev/null
+++ b/src/service/transport/test_transport_test_transport_address_switch_tcp_peer1.conf
@@ -0,0 +1,29 @@
+@INLINE@ template_cfg_peer1.conf
+
+[ats]
+UNSPECIFIED_QUOTA_IN = 8 KiB
+UNSPECIFIED_QUOTA_OUT = 8 KiB
+# LOOPBACK
+LOOPBACK_QUOTA_IN = 8 KiB
+LOOPBACK_QUOTA_OUT = 8 KiB
+# LAN
+LAN_QUOTA_IN = 8 KiB
+LAN_QUOTA_OUT = 8 KiB
+# WAN
+WAN_QUOTA_IN = 8 KiB
+WAN_QUOTA_OUT = 8 KiB
+# WLAN
+WLAN_QUOTA_IN = 8 KiB
+WLAN_QUOTA_OUT = 8 KiB
+# BLUETOOTH
+BLUETOOTH_QUOTA_IN = 8 KiB
+BLUETOOTH_QUOTA_OUT = 8 KiB
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/quota-tcp-p1/
+
+[transport]
+PLUGINS = tcp
+
+
+
diff --git a/src/service/transport/test_transport_test_transport_address_switch_tcp_peer2.conf b/src/service/transport/test_transport_test_transport_address_switch_tcp_peer2.conf
new file mode 100644
index 000000000..6855cd00d
--- /dev/null
+++ b/src/service/transport/test_transport_test_transport_address_switch_tcp_peer2.conf
@@ -0,0 +1,29 @@
+@INLINE@ template_cfg_peer2.conf
+
+[ats]
+UNSPECIFIED_QUOTA_IN = 8 KiB
+UNSPECIFIED_QUOTA_OUT = 8 KiB
+# LOOPBACK
+LOOPBACK_QUOTA_IN = 8 KiB
+LOOPBACK_QUOTA_OUT = 8 KiB
+# LAN
+LAN_QUOTA_IN = 8 KiB
+LAN_QUOTA_OUT = 8 KiB
+# WAN
+WAN_QUOTA_IN = 8 KiB
+WAN_QUOTA_OUT = 8 KiB
+# WLAN
+WLAN_QUOTA_IN = 8 KiB
+WLAN_QUOTA_OUT = 8 KiB
+# BLUETOOTH
+BLUETOOTH_QUOTA_IN = 8 KiB
+BLUETOOTH_QUOTA_OUT = 8 KiB
+
+
+[PATHS]
+GNUNET_TEST_HOME = $GNUNET_TMP/test-transport/api-tcp-p2/
+
+[transport]
+PLUGINS = tcp
+
+
diff --git a/src/service/transport/test_transport_testing_startstop.c b/src/service/transport/test_transport_testing_startstop.c
new file mode 100644
index 000000000..4783c1813
--- /dev/null
+++ b/src/service/transport/test_transport_testing_startstop.c
@@ -0,0 +1,138 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009, 2010, 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 transport/test_transport_testing_startstop.c
+ * @brief test case for transport testing library:
+ * start the peer, get the HELLO message and stop the peer
+ */
+#include "platform.h"
+#include "gnunet_transport_service.h"
+#include "transport-testing.h"
+
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
+
+
+static struct GNUNET_SCHEDULER_Task *timeout_task;
+
+static struct GNUNET_TRANSPORT_TESTING_PeerContext *p;
+
+static struct GNUNET_TRANSPORT_TESTING_Handle *tth;
+
+static int ret;
+
+
+static void
+end ()
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Stopping peers\n");
+  if (NULL != timeout_task)
+    GNUNET_SCHEDULER_cancel (timeout_task);
+  if (NULL != p)
+    GNUNET_TRANSPORT_TESTING_stop_peer (p);
+  if (NULL != tth)
+    GNUNET_TRANSPORT_TESTING_done (tth);
+}
+
+
+static void
+end_badly ()
+{
+  timeout_task = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Timeout!\n");
+  end ();
+  ret = GNUNET_SYSERR;
+}
+
+
+static void
+start_cb (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Peer %u (`%s') successfully started\n",
+              p->no,
+              GNUNET_i2s (&p->id));
+  ret = 0;
+  GNUNET_SCHEDULER_add_now (&end,
+                            NULL);
+}
+
+
+static void
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  ret = 1;
+  tth = GNUNET_TRANSPORT_TESTING_init ();
+  GNUNET_assert (NULL != tth);
+
+  timeout_task =
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
+                                  &end_badly,
+                                  NULL);
+
+  p = GNUNET_TRANSPORT_TESTING_start_peer (tth,
+                                           cfgfile,
+                                           1,
+                                           NULL, /* receive cb */
+                                           NULL, /* connect cb */
+                                           NULL, /* disconnect cb */
+                                           NULL, /* nc/nd closure */
+                                           &start_cb, /* startup cb */
+                                           NULL); /* closure */
+  if (NULL == p)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to start peer\n");
+    if (timeout_task != NULL)
+      GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
+  }
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  char *const argv_1[] = { "test_transport_testing",
+                           "-c",
+                           "test_transport_api_data.conf",
+                           NULL };
+  struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  GNUNET_log_setup ("test_transport_testing_startstop",
+                    "WARNING",
+                    NULL);
+  GNUNET_PROGRAM_run ((sizeof(argv_1) / sizeof(char *)) - 1,
+                      argv_1,
+                      "test_transport_testing_startstop", "nohelp",
+                      options,
+                      &run,
+                      &ret);
+
+  return ret;
+}
+
+
+/* end of test_transport_testing_startstop.c */
diff --git a/src/service/transport/test_transport_udp_backchannel.sh b/src/service/transport/test_transport_udp_backchannel.sh
new file mode 100755
index 000000000..1a7c83385
--- /dev/null
+++ b/src/service/transport/test_transport_udp_backchannel.sh
@@ -0,0 +1,14 @@
+#!/bin/bash
+if [ -f "test.out" ]; then
+    rm test.out
+fi
+if ! [ -d "/run/netns" ]; then
+    echo You have to create the directory /run/netns.
+fi
+if [ -f /proc/sys/kernel/unprivileged_userns_clone ]; then
+  if  [ "$(cat /proc/sys/kernel/unprivileged_userns_clone)" != 1 ]; then
+    echo -e "Error during test setup: The kernel parameter kernel.unprivileged_userns_clone has to be set to 1! One has to execute\n\n sysctl kernel.unprivileged_userns_clone=1\n"
+    exit 78
+  fi
+fi
+exec unshare -r -nmU bash -c "mount -t tmpfs --make-rshared tmpfs /run/netns; GNUNET_FORCE_LOG=';;;;DEBUG' GNUNET_FORCE_LOGFILE='test.out' ./test_transport_start_with_config test_transport_udp_backchannel_topo.conf"
diff --git a/src/service/transport/test_transport_udp_backchannel_topo.conf b/src/service/transport/test_transport_udp_backchannel_topo.conf
new file mode 100644
index 000000000..ad35bde0a
--- /dev/null
+++ b/src/service/transport/test_transport_udp_backchannel_topo.conf
@@ -0,0 +1,7 @@
+M:1
+N:1
+X:1
+T:libgnunet_test_transport_plugin_cmd_udp_backchannel
+K:1|{connect:{P:1:1:tcp}}
+R:1|{tcp_port:1}|{udp_port:0}
+P:1:1|{connect:{K:1:udp}}
diff --git a/src/service/transport/testing_transport_traits.c b/src/service/transport/testing_transport_traits.c
new file mode 100644
index 000000000..131c42a5d
--- /dev/null
+++ b/src/service/transport/testing_transport_traits.c
@@ -0,0 +1,35 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file transport/test_transport_start_with_config.c
+ * @brief Generic program to start testcases in an configurable topology.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_lib.h"
+#include "transport-testing-cmds.h"
+
+GNUNET_TRANSPORT_SIMPLE_TRAITS (GNUNET_TESTING_MAKE_IMPL_SIMPLE_TRAIT,
+                                GNUNET_TRANSPORT_TESTING)
+
+GNUNET_TRANSPORT_TESTING_SIMPLE_TRAITS (GNUNET_TESTING_MAKE_IMPL_SIMPLE_TRAIT,
+                                        GNUNET_TRANSPORT_TESTING)
diff --git a/src/service/transport/transport-testing-cmds.h b/src/service/transport/transport-testing-cmds.h
new file mode 100644
index 000000000..478b3cba6
--- /dev/null
+++ b/src/service/transport/transport-testing-cmds.h
@@ -0,0 +1,261 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2021 GNUnet e.V.
+
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Affero General Public License for more details.
+
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file transport-testing.h
+ * @brief testing lib for transport service
+ * @author Matthias Wachs
+ * @author Christian Grothoff
+ */
+#ifndef TRANSPORT_TESTING_CMDS_H
+#define TRANSPORT_TESTING_CMDS_H
+
+#include "gnunet_testing_lib.h"
+#include "gnunet_testing_transport_lib.h"
+
+
+/**
+ * Struct to store information needed in callbacks.
+ *
+ */
+// FIXME: breaks naming conventions! Needed public?
+struct ConnectPeersState
+{
+  /**
+   * Context for our asynchronous completion.
+   */
+  struct GNUNET_TESTING_AsyncContext ac;
+
+  GNUNET_TESTING_notify_connect_cb notify_connect;
+
+  /**
+   * The testing system of this node.
+   */
+  const struct GNUNET_TESTBED_System *tl_system;
+
+  // Label of the cmd which started the test system.
+  const char *create_label;
+
+  /**
+   * Number globally identifying the node.
+   *
+   */
+  uint32_t num;
+
+  /**
+   * Label of the cmd to start a peer.
+   *
+   */
+  const char *start_peer_label;
+
+  /**
+   * The topology of the test setup.
+   */
+  struct GNUNET_TESTING_NetjailTopology *topology;
+
+  /**
+   * Connections to other peers.
+   */
+  struct GNUNET_TESTING_NodeConnection *node_connections_head;
+
+  struct GNUNET_TESTING_Interpreter *is;
+
+  /**
+   * Number of connections.
+   */
+  unsigned int con_num;
+
+  /**
+   * Number of additional connects this cmd will wait for not triggered by this cmd.
+   */
+  unsigned int additional_connects;
+
+  /**
+ * Number of connections we already have a notification for.
+ */
+  unsigned int con_num_notified;
+
+  /**
+   * Number of additional connects this cmd will wait for not triggered by this cmd we already have a notification for.
+   */
+  unsigned int additional_connects_notified;
+
+  /**
+   * Flag indicating, whether the command is waiting for peers to connect that are configured to connect.
+   */
+  unsigned int wait_for_connect;
+};
+
+
+typedef void *
+(*GNUNET_TRANSPORT_notify_connect_cb) (struct GNUNET_TESTING_Interpreter *is,
+                                       const struct GNUNET_PeerIdentity *peer);
+
+
+struct TestState
+{
+  /**
+   * The name for a specific test environment directory.
+   *
+   */
+  char *testdir;
+
+  /**
+   * The name for the configuration file of the specific node.
+   *
+   */
+  char *cfgname;
+
+  /**
+   * The complete topology information.
+   */
+  struct GNUNET_TESTING_NetjailTopology *topology;
+};
+
+
+/**
+ * Create command.
+ *
+ * @param label name for command.
+ * @param system_label Label of the cmd to setup a test environment.
+ * @param no Decimal number representing the last byte of the IP address of this peer.
+ * @param node_ip The IP address of this node.
+ * @param handlers Handler for messages received by this peer.
+ * @param cfgname Configuration file name for this peer.
+ * @param notify_connect Method which will be called, when a peer connects.
+ * @param broadcast Flag indicating, if broadcast should be switched on.
+ * @return command.
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TRANSPORT_cmd_start_peer (const char *label,
+                                 const char *system_label,
+                                 uint32_t no,
+                                 const char *node_ip,
+                                 struct GNUNET_MQ_MessageHandler *handlers,
+                                 const char *cfgname,
+                                 GNUNET_TRANSPORT_notify_connect_cb
+                                 notify_connect,
+                                 unsigned int broadcast);
+
+
+struct GNUNET_TESTING_Command
+GNUNET_TRANSPORT_cmd_stop_peer (const char *label,
+                                const char *start_label);
+
+
+/**
+ * Create command
+ *
+ * @param label name for command
+ * @param start_peer_label Label of the cmd to start a peer.
+ * @param create_label Label of the cmd which started the test system.
+ * @param num Number globally identifying the node.
+ * @param topology The topology for the test setup.
+ * @param additional_connects Number of additional connects this cmd will wait for not triggered by this cmd.
+ * @return command.
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TRANSPORT_cmd_connect_peers (
+  const char *label,
+  const char *start_peer_label,
+  const char *create_label,
+  uint32_t num,
+  struct GNUNET_TESTING_NetjailTopology *topology,
+  unsigned int additional_connects,
+  unsigned int wait_for_connect);
+
+
+/**
+ * Create command.
+ *
+ * @param label name for command.
+ * @param start_peer_label Label of the cmd to start a peer.
+ * @param create_label Label of the cmd which started the test system.
+ * @param num Number globally identifying the node.
+ * @param topology The topology for the test setup.
+ * @return command.
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TRANSPORT_cmd_send_simple (const char *label,
+                                  const char *start_peer_label,
+                                  const char *create_label,
+                                  uint32_t num,
+                                  struct GNUNET_TESTING_NetjailTopology *
+                                  topology);
+
+/**
+ *
+ *
+ * @param label name for command.
+ * @param start_peer_label Label of the cmd to start a peer.
+ * @param create_label Label of the cmd which started the test system.
+ * @param num Number globally identifying the node.
+ * @param size The size of the test message to send.
+ * @param max_send The number of messages to send.
+ * @param topology The topology for the test setup.
+ * @return command.
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TRANSPORT_cmd_send_simple_performance (const char *label,
+                                              const char *start_peer_label,
+                                              const char *create_label,
+                                              uint32_t num,
+                                              int size,
+                                              int max_send,
+                                              struct
+                                              GNUNET_TESTING_NetjailTopology *
+                                              topology);
+
+
+/**
+ * Create command.
+ *
+ * @param label name for command.
+ * @param start_peer_label Label of the cmd to start a peer.
+ * @param create_label Label of the cmd to create the testing system.
+ * @param num Number globally identifying the node.
+ * @param node_n The number of the node in a network namespace.
+ * @param namespace_n The number of the network namespace.
+ * @param topology The topology for the test setup.
+ * @return command.
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TRANSPORT_cmd_backchannel_check (const char *label,
+                                        const char *start_peer_label,
+                                        const char *create_label,
+                                        uint32_t num,
+                                        unsigned int node_n,
+                                        unsigned int namespace_n,
+                                        struct GNUNET_TESTING_NetjailTopology *
+                                        topology);
+
+
+/**
+ * Call #op on all simple traits.
+ */
+#define GNUNET_TRANSPORT_SIMPLE_TRAITS(op, prefix)                 \
+        op (prefix, connect_peer_state, const struct ConnectPeersState)
+
+GNUNET_TRANSPORT_SIMPLE_TRAITS (GNUNET_TESTING_MAKE_DECL_SIMPLE_TRAIT,
+                                GNUNET_TRANSPORT_TESTING)
+
+
+#endif
+/* end of transport_testing.h */
diff --git a/src/service/transport/transport-testing-communicator.c b/src/service/transport/transport-testing-communicator.c
new file mode 100644
index 000000000..9ee70fe7b
--- /dev/null
+++ b/src/service/transport/transport-testing-communicator.c
@@ -0,0 +1,1251 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2019 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 transport/transport-testing-communicator.c
+ * @brief functions related to testing-tng
+ * @author Christian Grothoff
+ * @author Julius Bünger
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_constants.h"
+#include "transport-testing-communicator.h"
+#include "gnunet_signatures.h"
+#include "transport.h"
+#include "gnunet_hello_uri_lib.h"
+#include <inttypes.h>
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "transport-testing2", __VA_ARGS__)
+
+struct MyClient
+{
+  struct MyClient *prev;
+  struct MyClient *next;
+  /**
+   * @brief Handle to the client
+   */
+  struct GNUNET_SERVICE_Client *client;
+
+  /**
+   * @brief Handle to the client
+   */
+  struct GNUNET_MQ_Handle *c_mq;
+
+  /**
+   * The TCH
+   */
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc;
+
+};
+
+/**
+ * @brief Queue of a communicator and some context
+ */
+struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue
+{
+  /**
+   * @brief Handle to the TransportCommunicator
+   */
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h;
+
+  /**
+   * @brief Envelope to a message that requests the opening of the queue.
+   *
+   * If the client already requests queue(s), but the communicator is not yet
+   * connected, we cannot send the request to open the queue. Save it until the
+   * communicator becomes available and send it then.
+   */
+  struct GNUNET_MQ_Envelope *open_queue_env;
+
+  /**
+   * @brief Peer ID of the peer on the other side of the queue
+   */
+  struct GNUNET_PeerIdentity peer_id;
+
+  /**
+   * @brief Queue ID
+   */
+  uint32_t qid;
+
+  /**
+   * @brief Current message id
+   */
+  uint64_t mid;
+
+  /**
+   * An `enum GNUNET_NetworkType` in NBO.
+   */
+  uint32_t nt;
+
+  /**
+   * Maximum transmission unit.  UINT32_MAX for unlimited.
+   */
+  uint32_t mtu;
+
+  /**
+   * Queue length.  UINT64_MAX for unlimited.
+   */
+  uint64_t q_len;
+
+  /**
+   * Queue prio
+   */
+  uint32_t priority;
+
+  /**
+   * An `enum GNUNET_TRANSPORT_ConnectionStatus` in NBO.
+   */
+  uint32_t cs;
+
+  /**
+   * @brief Next element inside a DLL
+   */
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *next;
+
+  /**
+   * @brief Previous element inside a DLL
+   */
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *prev;
+};
+
+
+/**
+ * @brief Handle/Context to a single transmission
+ */
+struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorTransmission
+{
+};
+
+
+/**
+ * @brief Check whether incoming msg indicating available communicator is
+ * correct
+ *
+ * @param cls Closure
+ * @param msg Message struct
+ *
+ * @return GNUNET_YES in case message is correct
+ */
+static int
+check_communicator_available (
+  void *cls,
+  const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *msg)
+{
+  uint16_t size;
+
+  size = ntohs (msg->header.size) - sizeof(*msg);
+  if (0 == size)
+    return GNUNET_OK; /* receive-only communicator */
+  GNUNET_MQ_check_zero_termination (msg);
+  return GNUNET_OK;
+}
+
+
+/**
+ * @brief Handle new communicator
+ *
+ * Store characteristics of communicator, call respective client callback.
+ *
+ * @param cls Closure - communicator handle
+ * @param msg Message struct
+ */
+static void
+handle_communicator_available (
+  void *cls,
+  const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *msg)
+{
+  struct MyClient *client = cls;
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h =
+    client->tc;
+  uint16_t size;
+  tc_h->c_mq = client->c_mq;
+
+  size = ntohs (msg->header.size) - sizeof(*msg);
+  if (0 == size)
+  {
+    GNUNET_SERVICE_client_continue (client->client);
+    return; /* receive-only communicator */
+  }
+  tc_h->c_characteristics = ntohl (msg->cc);
+  GNUNET_free (tc_h->c_addr_prefix);
+  tc_h->c_addr_prefix = GNUNET_strdup ((const char *) &msg[1]);
+  if (NULL != tc_h->communicator_available_cb)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "calling communicator_available_cb()\n");
+    tc_h->communicator_available_cb (tc_h->cb_cls,
+                                     tc_h,
+                                     tc_h->c_characteristics,
+                                     tc_h->c_addr_prefix);
+  }
+  GNUNET_SERVICE_client_continue (client->client);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "finished communicator_available_cb()\n");
+
+}
+
+
+/**
+ * Incoming message.  Test message is well-formed.
+ *
+ * @param cls the client
+ * @param msg the send message that was sent
+ * @return #GNUNET_OK if message is well-formed
+ */
+static int
+check_communicator_backchannel (void *cls,
+                                const struct
+                                GNUNET_TRANSPORT_CommunicatorBackchannel *msg)
+{
+  // struct TransportClient *tc = cls;
+
+  // if (CT_COMMUNICATOR != tc->type)
+  // {
+  //  GNUNET_break (0);
+  //  return GNUNET_SYSERR;
+  // }
+  // GNUNET_MQ_check_boxed_message (msg);
+  return GNUNET_OK;
+}
+
+
+/**
+ * @brief Receive an incoming message.
+ *
+ * Pass the message to the client.
+ *
+ * @param cls Closure - communicator handle
+ * @param bc_msg Message
+ */
+static void
+handle_communicator_backchannel (void *cls,
+                                 const struct
+                                 GNUNET_TRANSPORT_CommunicatorBackchannel *
+                                 bc_msg)
+{
+  struct MyClient *client = cls;
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h =
+    client->tc;
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *other_tc_h;
+  struct GNUNET_MessageHeader *msg;
+  msg = (struct GNUNET_MessageHeader *) &bc_msg[1];
+  uint16_t isize = ntohs (msg->size);
+  const char *target_communicator = ((const char *) msg) + isize;
+  struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming *cbi;
+  struct GNUNET_MQ_Envelope *env;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received backchannel message\n");
+  if (tc_h->bc_enabled != GNUNET_YES)
+  {
+    GNUNET_SERVICE_client_continue (client->client);
+    return;
+  }
+  /* Find client providing this communicator */
+  /* Finally, deliver backchannel message to communicator */
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Delivering backchannel message of type %u to %s\n",
+       ntohs (msg->type),
+       target_communicator);
+  other_tc_h = tc_h->bc_cb (tc_h, msg, (struct
+                                        GNUNET_PeerIdentity*) &bc_msg->pid);
+  env = GNUNET_MQ_msg_extra (
+    cbi,
+    isize,
+    GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL_INCOMING);
+  cbi->pid = tc_h->peer_id;
+  memcpy (&cbi[1], msg, isize);
+
+
+  GNUNET_MQ_send (other_tc_h->c_mq, env);
+  GNUNET_SERVICE_client_continue (client->client);
+}
+
+
+/**
+ * Address of our peer added.  Test message is well-formed.
+ *
+ * @param cls the client
+ * @param msg the send message that was sent
+ * @return #GNUNET_OK if message is well-formed
+ */
+static int
+check_add_address (void *cls,
+                   const struct GNUNET_TRANSPORT_AddAddressMessage *msg)
+{
+  // if (CT_COMMUNICATOR != tc->type)
+  // {
+  //  GNUNET_break (0);
+  //  return GNUNET_SYSERR;
+  // }
+  GNUNET_MQ_check_zero_termination (msg);
+  return GNUNET_OK;
+}
+
+
+/**
+ * @brief The communicator informs about an address.
+ *
+ * Store address and call client callback.
+ *
+ * @param cls Closure - communicator handle
+ * @param msg Message
+ */
+static void
+handle_add_address (void *cls,
+                    const struct GNUNET_TRANSPORT_AddAddressMessage *msg)
+{
+  struct MyClient *client = cls;
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h =
+    client->tc;
+  uint16_t size;
+  size = ntohs (msg->header.size) - sizeof(*msg);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "received add address cb %u\n", size);
+  if (0 == size)
+    return; /* receive-only communicator */
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "received add address cb %u\n", size);
+  GNUNET_free (tc_h->c_address);
+  tc_h->c_address = GNUNET_strdup ((const char *) &msg[1]);
+  if (NULL != tc_h->add_address_cb)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "calling add_address_cb()\n");
+    tc_h->add_address_cb (tc_h->cb_cls,
+                          tc_h,
+                          tc_h->c_address,
+                          GNUNET_TIME_relative_ntoh (msg->expiration),
+                          msg->aid,
+                          ntohl (msg->nt));
+  }
+  GNUNET_SERVICE_client_continue (client->client);
+}
+
+
+/**
+ * Incoming message.  Test message is well-formed.
+ *
+ * @param cls the client
+ * @param msg the send message that was sent
+ * @return #GNUNET_OK if message is well-formed
+ */
+static int
+check_incoming_msg (void *cls,
+                    const struct GNUNET_TRANSPORT_IncomingMessage *msg)
+{
+  // struct TransportClient *tc = cls;
+
+  // if (CT_COMMUNICATOR != tc->type)
+  // {
+  //  GNUNET_break (0);
+  //  return GNUNET_SYSERR;
+  // }
+  GNUNET_MQ_check_boxed_message (msg);
+  return GNUNET_OK;
+}
+
+
+/**
+ * @brief Receive an incoming message.
+ *
+ * Pass the message to the client.
+ *
+ * @param cls Closure - communicator handle
+ * @param inc_msg Message
+ */
+static void
+handle_incoming_msg (void *cls,
+                     const struct GNUNET_TRANSPORT_IncomingMessage *inc_msg)
+{
+  struct MyClient *client = cls;
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h =
+    client->tc;
+  struct GNUNET_MessageHeader *msg;
+  msg = (struct GNUNET_MessageHeader *) &inc_msg[1];
+  size_t payload_len = ntohs (msg->size) - sizeof (struct
+                                                   GNUNET_MessageHeader);
+  if (NULL != tc_h->incoming_msg_cb)
+  {
+    tc_h->incoming_msg_cb (tc_h->cb_cls,
+                           tc_h,
+                           (char*) &msg[1],
+                           payload_len);
+  }
+  else
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Incoming message from communicator but no handler!\n");
+  }
+  if (GNUNET_YES == ntohl (inc_msg->fc_on))
+  {
+    /* send ACK when done to communicator for flow control! */
+    struct GNUNET_MQ_Envelope *env;
+    struct GNUNET_TRANSPORT_IncomingMessageAck *ack;
+
+    env = GNUNET_MQ_msg (ack, GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK);
+    GNUNET_assert (NULL != env);
+    ack->reserved = htonl (0);
+    ack->fc_id = inc_msg->fc_id;
+    ack->sender = inc_msg->sender;
+    GNUNET_MQ_send (tc_h->c_mq, env);
+  }
+
+  GNUNET_SERVICE_client_continue (client->client);
+}
+
+
+/**
+ * @brief Communicator informs that it tries to establish requested queue
+ *
+ * @param cls Closure - communicator handle
+ * @param msg Message
+ */
+static void
+handle_queue_create_ok (void *cls,
+                        const struct GNUNET_TRANSPORT_CreateQueueResponse *msg)
+{
+  struct MyClient *client = cls;
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h =
+    client->tc;
+
+  if (NULL != tc_h->queue_create_reply_cb)
+  {
+    tc_h->queue_create_reply_cb (tc_h->cb_cls, tc_h, GNUNET_YES);
+  }
+  GNUNET_SERVICE_client_continue (client->client);
+}
+
+
+/**
+ * @brief Communicator informs that it won't try establishing requested queue.
+ *
+ * It will not do so probably because the address is bougus (see comment to
+ * #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_FAIL)
+ *
+ * @param cls Closure - communicator handle
+ * @param msg Message
+ */
+static void
+handle_queue_create_fail (
+  void *cls,
+  const struct GNUNET_TRANSPORT_CreateQueueResponse *msg)
+{
+  struct MyClient *client = cls;
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h =
+    client->tc;
+
+  if (NULL != tc_h->queue_create_reply_cb)
+  {
+    tc_h->queue_create_reply_cb (tc_h->cb_cls, tc_h, GNUNET_NO);
+  }
+  GNUNET_SERVICE_client_continue (client->client);
+}
+
+
+/**
+ * New queue became available.  Check message.
+ *
+ * @param cls the client
+ * @param aqm the send message that was sent
+ */
+static int
+check_add_queue_message (void *cls,
+                         const struct GNUNET_TRANSPORT_AddQueueMessage *aqm)
+{
+  GNUNET_MQ_check_zero_termination (aqm);
+  return GNUNET_OK;
+}
+
+
+/**
+ * @brief Handle new queue
+ *
+ * Store context and call client callback.
+ *
+ * @param cls Closure - communicator handle
+ * @param msg Message struct
+ */
+static void
+handle_add_queue_message (void *cls,
+                          const struct GNUNET_TRANSPORT_AddQueueMessage *msg)
+{
+  struct MyClient *client = cls;
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h =
+    client->tc;
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *tc_queue;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Got queue with ID %u\n", msg->qid);
+  for (tc_queue = tc_h->queue_head; NULL != tc_queue; tc_queue = tc_queue->next)
+  {
+    if (tc_queue->qid == msg->qid)
+      break;
+  }
+  if (NULL == tc_queue)
+  {
+    tc_queue =
+      GNUNET_new (struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue);
+    tc_queue->tc_h = tc_h;
+    tc_queue->qid = msg->qid;
+    tc_queue->peer_id = msg->receiver;
+    GNUNET_CONTAINER_DLL_insert (tc_h->queue_head, tc_h->queue_tail, tc_queue);
+  }
+  GNUNET_assert (tc_queue->qid == msg->qid);
+  GNUNET_assert (0 == GNUNET_memcmp (&tc_queue->peer_id, &msg->receiver));
+  tc_queue->nt = msg->nt;
+  tc_queue->mtu = ntohl (msg->mtu);
+  tc_queue->cs = msg->cs;
+  tc_queue->priority = ntohl (msg->priority);
+  tc_queue->q_len = GNUNET_ntohll (msg->q_len);
+  if (NULL != tc_h->add_queue_cb)
+  {
+    tc_h->add_queue_cb (tc_h->cb_cls, tc_h, tc_queue, tc_queue->mtu);
+  }
+  GNUNET_SERVICE_client_continue (client->client);
+}
+
+
+/**
+ * @brief Handle new queue
+ *
+ * Store context and call client callback.
+ *
+ * @param cls Closure - communicator handle
+ * @param msg Message struct
+ */
+static void
+handle_update_queue_message (void *cls,
+                             const struct
+                             GNUNET_TRANSPORT_UpdateQueueMessage *msg)
+{
+  struct MyClient *client = cls;
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h =
+    client->tc;
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *tc_queue;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received queue update message for %u with q_len %" PRIu64 "\n",
+       msg->qid, GNUNET_ntohll (msg->q_len));
+  tc_queue = tc_h->queue_head;
+  if (NULL != tc_queue)
+  {
+    while (tc_queue->qid != msg->qid)
+    {
+      tc_queue = tc_queue->next;
+    }
+  }
+  if (NULL == tc_queue)
+  {
+    GNUNET_SERVICE_client_continue (client->client);
+    return;
+  }
+  GNUNET_assert (tc_queue->qid == msg->qid);
+  GNUNET_assert (0 == GNUNET_memcmp (&tc_queue->peer_id, &msg->receiver));
+  tc_queue->nt = msg->nt;
+  tc_queue->mtu = ntohl (msg->mtu);
+  tc_queue->cs = msg->cs;
+  tc_queue->priority = ntohl (msg->priority);
+  // Uncomment this for alternativ 1 of backchannel functionality
+  tc_queue->q_len += GNUNET_ntohll (msg->q_len);
+  // Until here for alternativ 1
+  // Uncomment this for alternativ 2 of backchannel functionality
+  // tc_queue->q_len = GNUNET_ntohll (msg->q_len);
+  // Until here for alternativ 2
+  GNUNET_SERVICE_client_continue (client->client);
+}
+
+
+/**
+ * @brief Shut down the service
+ *
+ * @param cls Closure - Handle to the service
+ */
+static void
+shutdown_service (void *cls)
+{
+  struct GNUNET_SERVICE_Handle *h = cls;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Shutting down service!\n");
+
+  GNUNET_SERVICE_stop (h);
+}
+
+
+/**
+ * @brief Callback called when new Client (Communicator) connects
+ *
+ * @param cls Closure - TransporCommmunicator Handle
+ * @param client Client
+ * @param mq Messagequeue
+ *
+ * @return TransportCommunicator Handle
+ */
+static void *
+connect_cb (void *cls,
+            struct GNUNET_SERVICE_Client *client,
+            struct GNUNET_MQ_Handle *mq)
+{
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
+  struct MyClient *new_c;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected to %p.\n",
+       client, tc_h);
+  new_c = GNUNET_new (struct MyClient);
+  new_c->client = client;
+  new_c->c_mq = mq;
+  new_c->tc = tc_h;
+  GNUNET_CONTAINER_DLL_insert (tc_h->client_head,
+                               tc_h->client_tail,
+                               new_c);
+
+  if (NULL == tc_h->queue_head)
+    return new_c;
+  /* Iterate over queues. They are yet to be opened. Request opening. */
+  for (struct
+       GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *tc_queue_iter =
+         tc_h->queue_head;
+       NULL != tc_queue_iter;
+       tc_queue_iter = tc_queue_iter->next)
+  {
+    if (NULL == tc_queue_iter->open_queue_env)
+      continue;
+    /* Send the previously created mq envelope to request the creation of the
+     * queue. */
+    GNUNET_MQ_send (tc_h->c_mq,
+                    tc_queue_iter->open_queue_env);
+    tc_queue_iter->open_queue_env = NULL;
+  }
+  return new_c;
+}
+
+
+/**
+ * @brief Callback called when Client disconnects
+ *
+ * @param cls Closure - TransportCommunicator Handle
+ * @param client Client
+ * @param internal_cls TransporCommmunicator Handle
+ */
+static void
+disconnect_cb (void *cls,
+               struct GNUNET_SERVICE_Client *client,
+               void *internal_cls)
+{
+  struct MyClient *cl = cls;
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h = cls;
+
+  for (cl = tc_h->client_head; NULL != cl; cl = cl->next)
+  {
+    if (cl->client != client)
+      continue;
+    GNUNET_CONTAINER_DLL_remove (tc_h->client_head,
+                                 tc_h->client_tail,
+                                 cl);
+    if (cl->c_mq == tc_h->c_mq)
+      tc_h->c_mq = NULL;
+    GNUNET_free (cl);
+    break;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Client disconnected.\n");
+}
+
+
+/**
+ * Message was transmitted.  Process the request.
+ *
+ * @param cls the client
+ * @param sma the send message that was sent
+ */
+static void
+handle_send_message_ack (void *cls,
+                         const struct GNUNET_TRANSPORT_SendMessageToAck *sma)
+{
+  struct MyClient *client = cls;
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h =
+    client->tc;
+  static int mtr = 0;
+  mtr++;
+  if (tc_h->cont != NULL)
+    tc_h->cont (tc_h->cont_cls);
+  GNUNET_SERVICE_client_continue (client->client);
+}
+
+
+/**
+ * @brief Start the communicator part of the transport service
+ *
+ * @param communicator_available Callback to be called when a new communicator
+ * becomes available
+ * @param cfg Configuration
+ */
+static void
+transport_communicator_start (
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h)
+{
+  struct GNUNET_MQ_MessageHandler mh[] = {
+    GNUNET_MQ_hd_var_size (communicator_available,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_NEW_COMMUNICATOR,
+                           struct GNUNET_TRANSPORT_CommunicatorAvailableMessage,
+                           tc_h),
+    GNUNET_MQ_hd_var_size (communicator_backchannel,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL,
+                           struct GNUNET_TRANSPORT_CommunicatorBackchannel,
+                           tc_h),
+    GNUNET_MQ_hd_var_size (add_address,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_ADD_ADDRESS,
+                           struct GNUNET_TRANSPORT_AddAddressMessage,
+                           tc_h),
+    // GNUNET_MQ_hd_fixed_size (del_address,
+    //                         GNUNET_MESSAGE_TYPE_TRANSPORT_DEL_ADDRESS,
+    //                         struct GNUNET_TRANSPORT_DelAddressMessage,
+    //                         NULL),
+    GNUNET_MQ_hd_var_size (incoming_msg,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG,
+                           struct GNUNET_TRANSPORT_IncomingMessage,
+                           tc_h),
+    GNUNET_MQ_hd_fixed_size (queue_create_ok,
+                             GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_OK,
+                             struct GNUNET_TRANSPORT_CreateQueueResponse,
+                             tc_h),
+    GNUNET_MQ_hd_fixed_size (queue_create_fail,
+                             GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_FAIL,
+                             struct GNUNET_TRANSPORT_CreateQueueResponse,
+                             tc_h),
+    GNUNET_MQ_hd_var_size (add_queue_message,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP,
+                           struct GNUNET_TRANSPORT_AddQueueMessage,
+                           tc_h),
+    GNUNET_MQ_hd_fixed_size (update_queue_message,
+                             GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_UPDATE,
+                             struct GNUNET_TRANSPORT_UpdateQueueMessage,
+                             tc_h),
+    // GNUNET_MQ_hd_fixed_size (del_queue_message,
+    //                         GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_TEARDOWN,
+    //                         struct GNUNET_TRANSPORT_DelQueueMessage,
+    //                         NULL),
+    GNUNET_MQ_hd_fixed_size (send_message_ack,
+                             GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG_ACK,
+                             struct GNUNET_TRANSPORT_SendMessageToAck,
+                             tc_h),
+    GNUNET_MQ_handler_end ()
+  };
+
+
+  tc_h->sh = GNUNET_SERVICE_start ("transport",
+                                   tc_h->cfg,
+                                   &connect_cb,
+                                   &disconnect_cb,
+                                   tc_h,
+                                   mh);
+  GNUNET_assert (NULL != tc_h->sh);
+}
+
+
+/**
+ * @brief Task run at shutdown to kill communicator and clean up
+ *
+ * @param cls Closure - Process of communicator
+ */
+static void
+shutdown_process (struct GNUNET_OS_Process *proc)
+{
+  if (0 != GNUNET_OS_process_kill (proc, SIGTERM))
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         "Error shutting down process with SIGERM, trying SIGKILL\n");
+    if (0 != GNUNET_OS_process_kill (proc, SIGKILL))
+    {
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           "Error shutting down process with SIGERM and SIGKILL\n");
+    }
+  }
+  GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (proc));
+  GNUNET_OS_process_destroy (proc);
+}
+
+
+/**
+ * @brief Task run at shutdown to kill the statistics process
+ *
+ * @param cls Closure - Process of communicator
+ */
+static void
+shutdown_statistics (void *cls)
+{
+  struct GNUNET_OS_Process *proc = cls;
+  shutdown_process (proc);
+}
+
+
+/**
+ * @brief Task run at shutdown to kill the peerstore process
+ *
+ * @param cls Closure - Process of communicator
+ */
+static void
+shutdown_peerstore (void *cls)
+{
+  struct GNUNET_OS_Process *proc = cls;
+  shutdown_process (proc);
+}
+
+
+/**
+ * @brief Task run at shutdown to kill a communicator process
+ *
+ * @param cls Closure - Process of communicator
+ */
+static void
+shutdown_communicator (void *cls)
+{
+  struct GNUNET_OS_Process *proc = cls;
+  shutdown_process (proc);
+}
+
+
+/**
+ * @brief Start the communicator
+ *
+ * @param cfgname Name of the communicator
+ */
+static void
+communicator_start (
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h,
+  const char *binary_name)
+{
+  char *binary;
+  char *loprefix;
+  char *section_name;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "communicator_start\n");
+
+  section_name = strchr (binary_name, '-');
+  section_name++;
+
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (tc_h->cfg,
+                                                          section_name,
+                                                          "PREFIX",
+                                                          &loprefix))
+    loprefix = GNUNET_strdup ("");
+
+
+  binary = GNUNET_OS_get_libexec_binary_path (binary_name);
+  tc_h->c_proc = GNUNET_OS_start_process_s (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+                                            NULL,
+                                            loprefix,
+                                            binary,
+                                            binary_name,
+                                            "-c",
+                                            tc_h->cfg_filename,
+                                            NULL);
+  GNUNET_free (loprefix);
+  if (NULL == tc_h->c_proc)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to start communicator!");
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_INFO, "started communicator\n");
+  GNUNET_free (binary);
+}
+
+
+/**
+ * @brief Task run at shutdown to kill communicator and clean up
+ *
+ * @param cls Closure - Process of communicator
+ */
+static void
+shutdown_nat (void *cls)
+{
+  struct GNUNET_OS_Process *proc = cls;
+  shutdown_process (proc);
+}
+
+
+/**
+ * @brief Task run at shutdown to kill the resolver process
+ *
+ * @param cls Closure - Process of communicator
+ */
+static void
+shutdown_resolver (void *cls)
+{
+  struct GNUNET_OS_Process *proc = cls;
+  shutdown_process (proc);
+}
+
+
+/**
+ * @brief Start Resolver
+ *
+ */
+static void
+resolver_start (struct
+                GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h)
+{
+  char *binary;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "resolver_start\n");
+  binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-resolver");
+  tc_h->resolver_proc = GNUNET_OS_start_process (
+    GNUNET_OS_INHERIT_STD_OUT_AND_ERR
+    | GNUNET_OS_USE_PIPE_CONTROL,
+    NULL,
+    NULL,
+    NULL,
+    binary,
+    "gnunet-service-resolver",
+    "-c",
+    tc_h->cfg_filename,
+    NULL);
+  if (NULL == tc_h->resolver_proc)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to start resolver service!");
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_INFO, "started resolver service\n");
+  GNUNET_free (binary);
+
+}
+
+
+/**
+ * @brief Start Statistics
+ *
+ */
+static void
+statistics_start (
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h)
+{
+  char *binary;
+
+  binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-statistics");
+  tc_h->stat_proc = GNUNET_OS_start_process (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+                                             NULL,
+                                             NULL,
+                                             NULL,
+                                             binary,
+                                             "gnunet-service-statistics",
+                                             "-c",
+                                             tc_h->cfg_filename,
+                                             NULL);
+  if (NULL == tc_h->stat_proc)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to start Statistics!");
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_INFO, "started Statistics\n");
+  GNUNET_free (binary);
+}
+
+
+/**
+ * @brief Start Peerstore
+ *
+ */
+static void
+peerstore_start (
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h)
+{
+  char *binary;
+
+  binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-peerstore");
+  tc_h->ps_proc = GNUNET_OS_start_process (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+                                           NULL,
+                                           NULL,
+                                           NULL,
+                                           binary,
+                                           "gnunet-service-peerstore",
+                                           "-c",
+                                           tc_h->cfg_filename,
+                                           NULL);
+  if (NULL == tc_h->ps_proc)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to start Peerstore!");
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_INFO, "started Peerstore\n");
+  GNUNET_free (binary);
+}
+
+
+/**
+ * @brief Start NAT
+ *
+ */
+static void
+nat_start (
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h)
+{
+  char *binary;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "nat_start\n");
+  binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-nat");
+  tc_h->nat_proc = GNUNET_OS_start_process (GNUNET_OS_INHERIT_STD_OUT_AND_ERR
+                                            | GNUNET_OS_USE_PIPE_CONTROL,
+                                            NULL,
+                                            NULL,
+                                            NULL,
+                                            binary,
+                                            "gnunet-service-nat",
+                                            "-c",
+                                            tc_h->cfg_filename,
+                                            NULL);
+  if (NULL == tc_h->nat_proc)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to start NAT!");
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_INFO, "started NAT\n");
+  GNUNET_free (binary);
+}
+
+
+/**
+ * @brief Start communicator part of transport service and communicator
+ *
+ * @param service_name Name of the service
+ * @param cfg Configuration handle
+ * @param communicator_available_cb Callback that is called when a new
+ * @param add_address_cb Callback that is called when a new
+ * communicator becomes available
+ * @param cb_cls Closure to @a communicator_available_cb and @a
+ *
+ * @return Handle to the communicator duo
+ */
+struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *
+GNUNET_TRANSPORT_TESTING_transport_communicator_service_start (
+  const char *service_name,
+  const char *binary_name,
+  const char *cfg_filename,
+  const struct GNUNET_PeerIdentity *peer_id,
+  GNUNET_TRANSPORT_TESTING_CommunicatorAvailableCallback
+  communicator_available_cb,
+  GNUNET_TRANSPORT_TESTING_AddAddressCallback add_address_cb,
+  GNUNET_TRANSPORT_TESTING_QueueCreateReplyCallback queue_create_reply_cb,
+  GNUNET_TRANSPORT_TESTING_AddQueueCallback add_queue_cb,
+  GNUNET_TRANSPORT_TESTING_IncomingMessageCallback incoming_message_cb,
+  GNUNET_TRANSPORT_TESTING_BackchannelCallback bc_cb,
+  void *cb_cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Starting new transport/communicator combo with config %s\n",
+       cfg_filename);
+  tc_h =
+    GNUNET_new (struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle);
+  tc_h->cfg_filename = GNUNET_strdup (cfg_filename);
+  tc_h->cfg = GNUNET_CONFIGURATION_create ();
+  if ((GNUNET_SYSERR == GNUNET_CONFIGURATION_load (tc_h->cfg, cfg_filename)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Malformed configuration file `%s', exit ...\n"),
+                cfg_filename);
+    GNUNET_free (tc_h->cfg_filename);
+    GNUNET_CONFIGURATION_destroy (tc_h->cfg);
+    GNUNET_free (tc_h);
+    return NULL;
+  }
+  tc_h->bc_enabled = GNUNET_CONFIGURATION_get_value_yesno (tc_h->cfg,
+                                                           "communicator-test",
+                                                           "BACKCHANNEL_ENABLED");
+  tc_h->communicator_available_cb = communicator_available_cb;
+  tc_h->add_address_cb = add_address_cb;
+  tc_h->queue_create_reply_cb = queue_create_reply_cb;
+  tc_h->add_queue_cb = add_queue_cb;
+  tc_h->incoming_msg_cb = incoming_message_cb;
+  tc_h->bc_cb = bc_cb;
+  tc_h->peer_id = *peer_id;
+  tc_h->cb_cls = cb_cls;
+
+  /* Start communicator part of service */
+  transport_communicator_start (tc_h);
+  /* Start NAT */
+  nat_start (tc_h);
+  /* Start resolver service */
+  resolver_start (tc_h);
+  /* Start peerstore service */
+  peerstore_start (tc_h);
+  /* Start statistic service */
+  statistics_start (tc_h);
+  /* Schedule start communicator */
+  communicator_start (tc_h,
+                      binary_name);
+  return tc_h;
+}
+
+
+void
+GNUNET_TRANSPORT_TESTING_transport_communicator_service_stop (
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h)
+{
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *queue;
+  shutdown_communicator (tc_h->c_proc);
+  shutdown_service (tc_h->sh);
+  shutdown_nat (tc_h->nat_proc);
+  shutdown_resolver (tc_h->resolver_proc);
+  shutdown_peerstore (tc_h->ps_proc);
+  shutdown_statistics (tc_h->stat_proc);
+  GNUNET_CONFIGURATION_destroy (tc_h->cfg);
+  while (NULL != (queue = tc_h->queue_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (tc_h->queue_head, tc_h->queue_tail, queue);
+    GNUNET_free (queue);
+  }
+  GNUNET_free (tc_h->c_address);
+  GNUNET_free (tc_h->cfg_filename);
+  GNUNET_free (tc_h->c_addr_prefix);
+  GNUNET_free (tc_h);
+}
+
+
+/**
+ * @brief Instruct communicator to open a queue
+ *
+ * @param tc_h Handle to communicator which shall open queue
+ * @param peer_id Towards which peer
+ * @param address For which address
+ */
+void
+GNUNET_TRANSPORT_TESTING_transport_communicator_open_queue (
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h,
+  const struct GNUNET_PeerIdentity *peer_id,
+  const char *address)
+{
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *tc_queue;
+  static uint32_t idgen;
+  char *prefix;
+  struct GNUNET_TRANSPORT_CreateQueue *msg;
+  struct GNUNET_MQ_Envelope *env;
+  size_t alen;
+
+  tc_queue =
+    GNUNET_new (struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue);
+  tc_queue->tc_h = tc_h;
+  prefix = GNUNET_HELLO_address_to_prefix (address);
+  if (NULL == prefix)
+  {
+    GNUNET_break (0);  /* We got an invalid address!? */
+    GNUNET_free (tc_queue);
+    return;
+  }
+  GNUNET_free (prefix);
+  alen = strlen (address) + 1;
+  env =
+    GNUNET_MQ_msg_extra (msg, alen, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE);
+  msg->request_id = htonl (idgen++);
+  tc_queue->qid = msg->request_id;
+  msg->receiver = *peer_id;
+  tc_queue->peer_id = *peer_id;
+  memcpy (&msg[1], address, alen);
+  if (NULL != tc_h->c_mq)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Sending queue create immediately\n");
+    GNUNET_MQ_send (tc_h->c_mq, env);
+  }
+  else
+  {
+    tc_queue->open_queue_env = env;
+  }
+  GNUNET_CONTAINER_DLL_insert (tc_h->queue_head, tc_h->queue_tail, tc_queue);
+}
+
+
+void
+GNUNET_TRANSPORT_TESTING_transport_communicator_send
+  (struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h,
+  GNUNET_SCHEDULER_TaskCallback cont,
+  void *cont_cls,
+  const void *payload,
+  size_t payload_size)
+{
+  struct GNUNET_MessageHeader *mh;
+  struct GNUNET_TRANSPORT_SendMessageTo *msg;
+  struct GNUNET_MQ_Envelope *env;
+  size_t inbox_size;
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *tc_queue;
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *tc_queue_tmp;
+  static struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *last_queue;
+  tc_queue = NULL;
+
+  for (tc_queue_tmp = tc_h->queue_head;
+       NULL != tc_queue_tmp;
+       tc_queue_tmp = tc_queue_tmp->next)
+  {
+    if (tc_queue_tmp->q_len <= 0)
+      continue;
+    if (NULL == tc_queue)
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Selecting queue with prio %u, len %" PRIu64 " and MTU %u\n",
+           tc_queue_tmp->priority,
+           tc_queue_tmp->q_len,
+           tc_queue_tmp->mtu);
+      tc_queue = tc_queue_tmp;
+      continue;
+    }
+    if (tc_queue->priority < tc_queue_tmp->priority)
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Selecting queue with prio %u, len %" PRIu64 " and MTU %u\n",
+           tc_queue_tmp->priority,
+           tc_queue_tmp->q_len,
+           tc_queue_tmp->mtu);
+      tc_queue = tc_queue_tmp;
+    }
+  }
+  if (last_queue != tc_queue)
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Selected sending queue changed to %u with length %lu and MTU %u\n",
+                ntohl (tc_queue->qid), (unsigned long) tc_queue->q_len, tc_queue->mtu);
+  GNUNET_assert (NULL != tc_queue);
+  last_queue = tc_queue;
+  // Uncomment this for alternativ 1 of backchannel functionality
+  if (tc_queue->q_len != GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED)
+    tc_queue->q_len--;
+  // Until here for alternativ 1
+  static int msg_count = 0;
+  msg_count++;
+  if (msg_count % 100 == 0)
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sending %u-th (%lu-th for queue) message on queue %u\n",
+                msg_count, (unsigned long) tc_queue->mid, ntohl (tc_queue->qid));
+  inbox_size = sizeof (struct GNUNET_MessageHeader) + payload_size;
+  env = GNUNET_MQ_msg_extra (msg,
+                             inbox_size,
+                             GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG);
+  GNUNET_assert (NULL != env);
+  msg->qid = tc_queue->qid;
+  msg->mid = tc_queue->mid++;
+  msg->receiver = tc_queue->peer_id;
+  mh = (struct GNUNET_MessageHeader *) &msg[1];
+  mh->size = htons (inbox_size);
+  mh->type = GNUNET_MESSAGE_TYPE_DUMMY;
+  memcpy (&mh[1],
+          payload,
+          payload_size);
+  if (NULL != cont)
+    GNUNET_MQ_notify_sent (env,
+                           cont,
+                           cont_cls);
+  GNUNET_MQ_send (tc_queue->tc_h->c_mq,
+                  env);
+}
diff --git a/src/service/transport/transport-testing-communicator.h b/src/service/transport/transport-testing-communicator.h
new file mode 100644
index 000000000..7460aab8e
--- /dev/null
+++ b/src/service/transport/transport-testing-communicator.h
@@ -0,0 +1,370 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2019 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 transport/transport-testing-communicator.h
+ * @brief functions and structures related to testing-tng
+ * @author Christian Grothoff
+ * @author Julius Bünger
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_transport_communication_service.h"
+#include "transport.h"
+
+/**
+ * @brief Queue of a communicator and some context
+ */
+struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue;
+
+
+/**
+ * @brief Handle/Context to a single transmission
+ */
+struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorTransmission;
+
+/**
+ * @brief Function signature for callbacks that are called when new
+ * backchannel message arrived
+ *
+ * @param cls Closure
+ * @param msg Backchannel message
+ * @param pid Target peer
+ */
+typedef struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *
+(*GNUNET_TRANSPORT_TESTING_BackchannelCallback)(void *cls,
+                                                struct GNUNET_MessageHeader *msg,
+                                                struct GNUNET_PeerIdentity *pid);
+
+
+/**
+ * @brief Function signature for callbacks that are called when new
+ * communicators become available
+ *
+ * @param cls Closure
+ * @param tc_h Communicator handle
+ * @param cc Characteristics of communicator
+ * @param address_prefix Prefix of the address
+ */
+typedef void
+(*GNUNET_TRANSPORT_TESTING_CommunicatorAvailableCallback)(void *cls,
+                                                          struct
+                                                          GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle
+                                                          *tc_h,
+                                                          enum
+                                                          GNUNET_TRANSPORT_CommunicatorCharacteristics
+                                                          cc,
+                                                          char *address_prefix);
+
+
+/**
+ * @brief Receive information about the address of a communicator.
+ *
+ * @param cls Closure
+ * @param tc_h Communicator handle
+ * @param address Address represented as string
+ * @param expiration Expiration
+ * @param aid Aid
+ * @param nt Network Type
+ */
+typedef void
+(*GNUNET_TRANSPORT_TESTING_AddAddressCallback)(void *cls,
+                                               struct
+                                               GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle
+                                               *tc_h,
+                                               const char *address,
+                                               struct GNUNET_TIME_Relative
+                                               expiration,
+                                               uint32_t aid,
+                                               enum GNUNET_NetworkType nt);
+
+
+/**
+ * @brief Get informed about the success of a queue request.
+ *
+ * @param cls Closure
+ * @param tc_h Communicator handle
+ * @param will_try #GNUNET_YES if communicator will try to create queue
+ */
+typedef void
+(*GNUNET_TRANSPORT_TESTING_QueueCreateReplyCallback)(void *cls,
+                                                     struct
+                                                     GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle
+                                                     *tc_h,
+                                                     int will_try);
+
+
+/**
+ * @brief Handle opening of queue
+ *
+ * @param cls Closure
+ * @param tc_h Communicator handle
+ * @param tc_queue Handle to newly opened queue
+ */
+typedef void
+(*GNUNET_TRANSPORT_TESTING_AddQueueCallback)(void *cls,
+                                             struct
+                                             GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle
+                                             *tc_h,
+                                             struct
+                                             GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue
+                                             *tc_queue,
+                                             size_t mtu);
+
+
+/**
+ * @brief Handle an incoming message
+ *
+ * @param cls Closure
+ * @param tc_h Handle to the receiving communicator
+ * @param msg Received message
+ */
+typedef void
+(*GNUNET_TRANSPORT_TESTING_IncomingMessageCallback)(void *cls,
+                                                    struct
+                                                    GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle
+                                                    *tc_h,
+                                                    const char*payload,
+                                                    size_t payload_len);
+
+/**
+ * @brief Handle to a transport communicator
+ */
+struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle
+{
+  /**
+   * Clients
+   */
+  struct MyClient *client_head;
+  struct MyClient *client_tail;
+
+  /**
+  * @brief Handle to the client
+  */
+  struct GNUNET_MQ_Handle *c_mq;
+
+  /**
+    * @brief Handle to the configuration
+    */
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * @brief File name of configuration file
+   */
+  char *cfg_filename;
+
+  struct GNUNET_PeerIdentity peer_id;
+
+  /**
+   * @brief Handle to the transport service
+   */
+  struct GNUNET_SERVICE_Handle *tsh;
+
+  /**
+   * @brief Task that will be run on shutdown to stop and clean transport
+   * service
+   */
+  struct GNUNET_SCHEDULER_Task *ts_shutdown_task;
+
+
+  /**
+   * @brief Process of the communicator
+   */
+  struct GNUNET_OS_Process *c_proc;
+
+  /**
+   * NAT process
+   */
+  struct GNUNET_OS_Process *nat_proc;
+
+  /**
+   * resolver service process
+   */
+  struct GNUNET_OS_Process *resolver_proc;
+
+  /**
+   * statistics service process
+   */
+  struct GNUNET_OS_Process *stat_proc;
+
+  /**
+   * peerstore service process
+   */
+  struct GNUNET_OS_Process *ps_proc;
+
+  /**
+   * @brief Task that will be run on shutdown to stop and clean communicator
+   */
+  struct GNUNET_SCHEDULER_Task *c_shutdown_task;
+
+  /**
+   * @brief Characteristics of the communicator
+   */
+  enum GNUNET_TRANSPORT_CommunicatorCharacteristics c_characteristics;
+
+  /**
+   * @brief Specifies supported addresses
+   */
+  char *c_addr_prefix;
+
+  /**
+   * @brief Specifies supported addresses
+   */
+  char *c_address;
+
+  /**
+   * @brief Head of the DLL of queues associated with this communicator
+   */
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *queue_head;
+
+  /**
+   * @brief Tail of the DLL of queues associated with this communicator
+   */
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *queue_tail;
+
+  /* Callbacks + Closures */
+  /**
+   * @brief Callback called when a new communicator connects
+   */
+  GNUNET_TRANSPORT_TESTING_CommunicatorAvailableCallback
+    communicator_available_cb;
+
+  /**
+   * @brief Callback called when a new communicator connects
+   */
+  GNUNET_TRANSPORT_TESTING_AddAddressCallback add_address_cb;
+
+  /**
+   * @brief Callback called when a new communicator connects
+   */
+  GNUNET_TRANSPORT_TESTING_QueueCreateReplyCallback queue_create_reply_cb;
+
+  /**
+   * @brief Callback called when a new communicator connects
+   */
+  GNUNET_TRANSPORT_TESTING_AddQueueCallback add_queue_cb;
+
+  /**
+   * @brief Callback called when a new communicator connects
+   */
+  GNUNET_TRANSPORT_TESTING_IncomingMessageCallback incoming_msg_cb;
+
+  /**
+   * @brief Backchannel callback
+   */
+  GNUNET_TRANSPORT_TESTING_BackchannelCallback bc_cb;
+
+  /**
+   * Our service handle
+   */
+  struct GNUNET_SERVICE_Handle *sh;
+
+  /**
+   * @brief Closure to the callback
+   */
+  void *cb_cls;
+
+  /**
+   * Callback to call when message ack received.
+   */
+  GNUNET_SCHEDULER_TaskCallback cont;
+
+  /**
+   * Closure for cont
+   */
+  void *cont_cls;
+
+  /**
+   * Backchannel supported
+   */
+  int bc_enabled;
+};
+
+/**
+ * @brief Start communicator part of transport service and communicator
+ *
+ * @param service_name Name of the service
+ * @param cfg Configuration handle
+ * @param communicator_available Callback that is called when a new
+ * communicator becomes available
+ * @param add_address_cb Callback handling new addresses
+ * @param queue_create_reply_cb Callback handling success of queue requests
+ * @param add_queue_cb Callback handling freshly created queues
+ * @param incoming_message_cb Callback handling incoming messages
+ * @param cb_cls Closure to @p communicator_available
+ *
+ * @return Handle to the communicator duo
+ */
+struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *
+GNUNET_TRANSPORT_TESTING_transport_communicator_service_start (
+  const char *service_name,
+  const char *binary_name,
+  const char *cfg_filename,
+  const struct GNUNET_PeerIdentity *peer_id,
+  GNUNET_TRANSPORT_TESTING_CommunicatorAvailableCallback
+  communicator_available_cb,
+  GNUNET_TRANSPORT_TESTING_AddAddressCallback add_address_cb,
+  GNUNET_TRANSPORT_TESTING_QueueCreateReplyCallback queue_create_reply_cb,
+  GNUNET_TRANSPORT_TESTING_AddQueueCallback add_queue_cb,
+  GNUNET_TRANSPORT_TESTING_IncomingMessageCallback incoming_message_cb,
+  GNUNET_TRANSPORT_TESTING_BackchannelCallback bc_cb,
+  void *cb_cls);
+
+
+void
+GNUNET_TRANSPORT_TESTING_transport_communicator_service_stop (
+  struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h);
+
+
+/**
+ * @brief Instruct communicator to open a queue
+ *
+ * @param tc_h Handle to communicator which shall open queue
+ * @param peer_id Towards which peer
+ * @param address For which address
+ */
+void
+GNUNET_TRANSPORT_TESTING_transport_communicator_open_queue (struct
+                                                            GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle
+                                                            *tc_h,
+                                                            const struct
+                                                            GNUNET_PeerIdentity
+                                                            *peer_id,
+                                                            const char *address);
+
+
+/**
+ * @brief Instruct communicator to send data
+ *
+ * @param tc_queue The queue to use for sending
+ * @param cont function to call when done sending
+ * @param cont_cls closure for @a cont
+ * @param payload Data to send
+ * @param payload_size Size of the @a payload
+ */
+void
+GNUNET_TRANSPORT_TESTING_transport_communicator_send (struct
+                                                      GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle
+                                                      *tc_h,
+                                                      GNUNET_SCHEDULER_TaskCallback
+                                                      cont,
+                                                      void *cont_cls,
+                                                      const void *payload,
+                                                      size_t payload_size);
diff --git a/src/service/transport/transport-testing-filenames2.c b/src/service/transport/transport-testing-filenames2.c
new file mode 100644
index 000000000..59fa1ebd5
--- /dev/null
+++ b/src/service/transport/transport-testing-filenames2.c
@@ -0,0 +1,203 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2006, 2009, 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 transport-testing-filenames.c
+ * @brief convenience string manipulation functions for tests
+ * @author Matthias Wachs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "transport-testing2.h"
+
+
+/**
+ * Removes all directory separators from absolute filename
+ *
+ * @param file the absolute file name, e.g. as found in argv[0]
+ * @return extracted file name, has to be freed by caller
+ */
+static char *
+extract_filename (const char *file)
+{
+  char *pch = GNUNET_strdup (file);
+  char *backup = pch;
+  char *filename = NULL;
+  char *res;
+
+  if (NULL != strstr (pch, "/"))
+  {
+    pch = strtok (pch, "/");
+    while (pch != NULL)
+    {
+      pch = strtok (NULL, "/");
+      if (pch != NULL)
+      {
+        filename = pch;
+      }
+    }
+  }
+  else
+    filename = pch;
+
+  res = GNUNET_strdup (filename);
+  GNUNET_free (backup);
+  return res;
+}
+
+
+/**
+ * Extracts the test filename from an absolute file name and removes
+ * the extension
+ *
+ * @param file absolute file name
+ * @return the result
+ */
+char *
+GNUNET_TRANSPORT_TESTING_get_test_name (const char *file)
+{
+  char *backup = extract_filename (file);
+  char *filename = backup;
+  char *dotexe;
+  char *ret;
+
+  if (NULL == filename)
+    return NULL;
+
+  /* remove "lt-" */
+  filename = strstr (filename, "test");
+  if (NULL == filename)
+  {
+    GNUNET_free (backup);
+    return NULL;
+  }
+
+  /* remove ".exe" */
+  if (NULL != (dotexe = strstr (filename, ".exe")))
+    dotexe[0] = '\0';
+  ret = GNUNET_strdup (filename);
+  GNUNET_free (backup);
+  return ret;
+}
+
+
+/**
+ * Extracts the filename from an absolute file name and removes the extension
+ *
+ * @param file absolute file name
+ * @return the result
+ */
+char *
+GNUNET_TRANSPORT_TESTING_get_test_source_name (const char *file)
+{
+  char *src = extract_filename (file);
+  char *split;
+
+  split = strstr (src, ".");
+  if (NULL != split)
+    split[0] = '\0';
+  return src;
+}
+
+
+/**
+ * Extracts the plugin name from an absolute file name and the test name
+ *
+ * @param file absolute file name
+ * @param test test name
+ * @return the result
+ */
+char *
+GNUNET_TRANSPORT_TESTING_get_test_plugin_name (const char *file,
+                                               const char *test)
+{
+  char *filename;
+  char *dotexe;
+  char *e = extract_filename (file);
+  char *t = extract_filename (test);
+  char *ret;
+
+  if (NULL == e)
+    goto fail;
+  /* remove "lt-" */
+  filename = strstr (e, "tes");
+  if (NULL == filename)
+    goto fail;
+  /* remove ".exe" */
+  if (NULL != (dotexe = strstr (filename, ".exe")))
+    dotexe[0] = '\0';
+
+  /* find last _ */
+  filename = strstr (filename, t);
+  if (NULL == filename)
+    goto fail;
+  /* copy plugin */
+  filename += strlen (t);
+  if ('\0' != *filename)
+    filename++;
+  ret = GNUNET_strdup (filename);
+  goto suc;
+fail:
+  ret = NULL;
+suc:
+  GNUNET_free (t);
+  GNUNET_free (e);
+  return ret;
+}
+
+
+/**
+ * This function takes the filename (e.g. argv[0), removes a "lt-"-prefix and
+ * if existing ".exe"-prefix and adds the peer-number
+ *
+ * @param file filename of the test, e.g. argv[0]
+ * @param count peer number
+ * @return the result
+ */
+char *
+GNUNET_TRANSPORT_TESTING_get_config_name (const char *file,
+                                          int count)
+{
+  char *filename = extract_filename (file);
+  char *backup = filename;
+  char *dotexe;
+  char *ret;
+
+  if (NULL == filename)
+    return NULL;
+  /* remove "lt-" */
+  filename = strstr (filename, "test");
+  if (NULL == filename)
+    goto fail;
+  /* remove ".exe" */
+  if (NULL != (dotexe = strstr (filename, ".exe")))
+    dotexe[0] = '\0';
+  GNUNET_asprintf (&ret,
+                   "%s_peer%u.conf",
+                   filename,
+                   count);
+  GNUNET_free (backup);
+  return ret;
+fail:
+  GNUNET_free (backup);
+  return NULL;
+}
+
+
+/* end of transport-testing-filenames.c */
diff --git a/src/service/transport/transport-testing-loggers2.c b/src/service/transport/transport-testing-loggers2.c
new file mode 100644
index 000000000..e6c79b78a
--- /dev/null
+++ b/src/service/transport/transport-testing-loggers2.c
@@ -0,0 +1,81 @@
+/*
+     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 transport-testing-loggers.c
+ * @brief convenience functions for logging common events in tests
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "transport-testing2.h"
+
+
+/**
+ * Log a connect event.
+ *
+ * @param cls NULL
+ * @param me peer that had the event
+ * @param other peer that connected.
+ */
+void
+GNUNET_TRANSPORT_TESTING_log_connect (void *cls,
+                                      struct
+                                      GNUNET_TRANSPORT_TESTING_PeerContext *me,
+                                      const struct GNUNET_PeerIdentity *other)
+{
+  char *ps;
+
+  ps = GNUNET_strdup (GNUNET_i2s (&me->id));
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Peer %s connected to %u (%s)!\n",
+              GNUNET_i2s (other),
+              me->no,
+              ps);
+  GNUNET_free (ps);
+}
+
+
+/**
+ * Log a disconnect event.
+ *
+ * @param cls NULL
+ * @param me peer that had the event
+ * @param other peer that disconnected.
+ */
+void
+GNUNET_TRANSPORT_TESTING_log_disconnect (void *cls,
+                                         struct
+                                         GNUNET_TRANSPORT_TESTING_PeerContext *
+                                         me,
+                                         const struct
+                                         GNUNET_PeerIdentity *other)
+{
+  char *ps;
+
+  ps = GNUNET_strdup (GNUNET_i2s (&me->id));
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Peer `%s' disconnected from %u (%s)!\n",
+              GNUNET_i2s (other),
+              me->no,
+              ps);
+  GNUNET_free (ps);
+}
+
+
+/* end of transport-testing-loggers.c */
diff --git a/src/service/transport/transport-testing-main2.c b/src/service/transport/transport-testing-main2.c
new file mode 100644
index 000000000..0a1710922
--- /dev/null
+++ b/src/service/transport/transport-testing-main2.c
@@ -0,0 +1,614 @@
+/*
+     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 transport-testing-main.c
+ * @brief convenience main function for tests
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "transport-testing2.h"
+
+
+/**
+ * Closure for #connect_cb.
+ */
+struct GNUNET_TRANSPORT_TESTING_ConnectRequestList
+{
+  /**
+   * Stored in a DLL.
+   */
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequestList *next;
+
+  /**
+   * Stored in a DLL.
+   */
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequestList *prev;
+
+  /**
+   * Overall context we are in.
+   */
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc;
+
+  /**
+   * Connect request this is about.
+   */
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cr;
+
+  /**
+   * Peer being connected.
+   */
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p1;
+
+  /**
+   * Peer being connected.
+   */
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p2;
+};
+
+
+/**
+ * Shutdown function for the test. Stops all peers.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *`
+ */
+static void
+do_shutdown (void *cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc = cls;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequestList *crl;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Testcase shutting down\n");
+  if (NULL != ccc->shutdown_task)
+    ccc->shutdown_task (ccc->shutdown_task_cls);
+  if (NULL != ccc->timeout_task)
+  {
+    GNUNET_SCHEDULER_cancel (ccc->timeout_task);
+    ccc->timeout_task = NULL;
+  }
+  if (NULL != ccc->connect_task)
+  {
+    GNUNET_SCHEDULER_cancel (ccc->connect_task);
+    ccc->connect_task = NULL;
+  }
+  while (NULL != (crl = ccc->crl_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (ccc->crl_head,
+                                 ccc->crl_tail,
+                                 crl);
+    GNUNET_TRANSPORT_TESTING_connect_peers_cancel (crl->cr);
+    GNUNET_free (crl);
+  }
+  for (unsigned int i = 0; i < ccc->num_peers; i++)
+  {
+    if (NULL != ccc->p[i])
+    {
+      GNUNET_TRANSPORT_TESTING_stop_peer (ccc->p[i]);
+      ccc->p[i] = NULL;
+    }
+  }
+}
+
+
+/**
+ * Testcase hit timeout, shut it down with error.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *`
+ */
+static void
+do_timeout (void *cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc = cls;
+
+  ccc->timeout_task = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Testcase timed out\n");
+  ccc->global_ret = GNUNET_SYSERR;
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * Internal data structure.   Closure for
+ * #connect_cb, #disconnect_cb, #my_nc and #start_cb.
+ * Allows us to identify which peer this is about.
+ */
+struct GNUNET_TRANSPORT_TESTING_InternalPeerContext
+{
+  /**
+   * Overall context of the callback.
+   */
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc;
+
+  /**
+   * Offset of the peer this is about.
+   */
+  unsigned int off;
+};
+
+
+/**
+ * Information tracked per connected peer.
+ */
+struct ConnectPairInfo
+{
+  /**
+   * Peer this is about.
+   */
+  const struct GNUNET_PeerIdentity *sender;
+
+  /**
+   * Information about the receiving peer.
+   */
+  struct GNUNET_TRANSPORT_TESTING_InternalPeerContext *ipi;
+};
+
+
+/**
+ * Function called when we connected two peers.  Once we have gotten
+ * to the clique, launch test-specific logic.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_TESTING_ConnectRequestList *`
+ */
+static void
+connect_cb (void *cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequestList *crl = cls;
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc = crl->ccc;
+
+  GNUNET_CONTAINER_DLL_remove (ccc->crl_head,
+                               ccc->crl_tail,
+                               crl);
+  {
+    char *p1_c = GNUNET_strdup (GNUNET_i2s (&crl->p1->id));
+
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Peers connected: %u (%s) <-> %u (%s)\n",
+                crl->p1->no,
+                p1_c,
+                crl->p2->no,
+                GNUNET_i2s (&crl->p2->id));
+    GNUNET_free (p1_c);
+    GNUNET_free (crl);
+  }
+  if (NULL == ccc->crl_head)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "All connections UP, launching custom test logic.\n");
+    GNUNET_SCHEDULER_add_now (ccc->connect_continuation,
+                              ccc->connect_continuation_cls);
+  }
+}
+
+
+/**
+ * Find peer by peer ID.
+ *
+ * @param ccc context to search
+ * @param peer peer to look for
+ * @return NULL if @a peer was not found
+ */
+struct GNUNET_TRANSPORT_TESTING_PeerContext *
+GNUNET_TRANSPORT_TESTING_find_peer (struct
+                                    GNUNET_TRANSPORT_TESTING_ConnectCheckContext
+                                    *ccc,
+                                    const struct GNUNET_PeerIdentity *peer)
+{
+  for (unsigned int i = 0; i < ccc->num_peers; i++)
+    if ((NULL != ccc->p[i]) &&
+        (0 == memcmp (peer,
+                      &ccc->p[i]->id,
+                      sizeof(*peer))))
+      return ccc->p[i];
+  return NULL;
+}
+
+
+/**
+ * Wrapper around peers connecting.  Calls client's nc function.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_TESTING_InternalPeerContext *`
+ * @param peer peer we got connected to
+ * @param mq message queue for transmissions to @a peer
+ * @return closure for message handlers
+ */
+static void *
+my_nc (void *cls,
+       const struct GNUNET_PeerIdentity *peer,
+       struct GNUNET_MQ_Handle *mq)
+{
+  struct GNUNET_TRANSPORT_TESTING_InternalPeerContext *ipi = cls;
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc = ipi->ccc;
+  struct ConnectPairInfo *cpi;
+
+  if (NULL != ccc->nc)
+    ccc->nc (ccc->cls,
+             ccc->p[ipi->off],
+             peer);
+  cpi = GNUNET_new (struct ConnectPairInfo);
+  cpi->ipi = ipi;
+  cpi->sender = peer; /* valid until disconnect */
+  return cpi;
+}
+
+
+/**
+ * Wrapper around peers disconnecting.  Calls client's nd function.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_TESTING_InternalPeerContext *`
+ * @param peer peer we got disconnected from
+ * @param custom_cls return value from @a my_nc
+ */
+static void
+my_nd (void *cls,
+       const struct GNUNET_PeerIdentity *peer,
+       void *custom_cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_InternalPeerContext *ipi = cls;
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc = ipi->ccc;
+  struct ConnectPairInfo *cpi = custom_cls;
+
+  if (NULL != ccc->nd)
+    ccc->nd (ccc->cls,
+             ccc->p[ipi->off],
+             peer);
+  GNUNET_free (cpi);
+}
+
+
+/**
+ * Wrapper around receiving data.  Calls client's rec function.
+ *
+ * @param cls our `struct ConnectPairInfo *`
+ * @param message message we received
+ * @return #GNUNET_OK (all messages are fine)
+ */
+static int
+check_test (void *cls,
+            const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
+{
+  return GNUNET_OK;
+}
+
+
+/**
+ * Wrapper around receiving data.  Calls client's rec function.
+ *
+ * @param cls our `struct ConnectPairInfo *`
+ * @param message message we received
+ */
+static void
+handle_test (void *cls,
+             const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
+{
+  struct ConnectPairInfo *cpi = cls;
+  struct GNUNET_TRANSPORT_TESTING_InternalPeerContext *ipi = cpi->ipi;
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc = ipi->ccc;
+
+  if (NULL != ccc->rec)
+    ccc->rec (ccc->cls,
+              ccc->p[ipi->off],
+              cpi->sender,
+              message);
+}
+
+
+/**
+ * Wrapper around receiving data.  Calls client's rec function.
+ *
+ * @param cls our `struct ConnectPairInfo *`
+ * @param message message we received
+ * @return #GNUNET_OK (all messages are fine)
+ */
+static int
+check_test2 (void *cls,
+             const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
+{
+  return GNUNET_OK;
+}
+
+
+/**
+ * Wrapper around receiving data.  Calls client's rec function.
+ *
+ * @param cls our `struct ConnectPairInfo *`
+ * @param message message we received
+ */
+static void
+handle_test2 (void *cls,
+              const struct GNUNET_TRANSPORT_TESTING_TestMessage *message)
+{
+  struct ConnectPairInfo *cpi = cls;
+  struct GNUNET_TRANSPORT_TESTING_InternalPeerContext *ipi = cpi->ipi;
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc = ipi->ccc;
+
+  if (NULL != ccc->rec)
+    ccc->rec (ccc->cls,
+              ccc->p[ipi->off],
+              cpi->sender,
+              message);
+}
+
+
+/**
+ * Connect the peers as a clique.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext`
+ */
+static void
+do_connect (void *cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc = cls;
+
+  ccc->connect_task = NULL;
+  for (unsigned int i = 0; i < ccc->num_peers; i++)
+    for (unsigned int j = (ccc->bi_directional ? 0 : i + 1); j < ccc->num_peers;
+         j++)
+    {
+      struct GNUNET_TRANSPORT_TESTING_ConnectRequestList *crl;
+
+      if (i == j)
+        continue;
+      crl = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_ConnectRequestList);
+      GNUNET_CONTAINER_DLL_insert (ccc->crl_head,
+                                   ccc->crl_tail,
+                                   crl);
+      crl->ccc = ccc;
+      crl->p1 = ccc->p[i];
+      crl->p2 = ccc->p[j];
+      {
+        char *sender_c = GNUNET_strdup (GNUNET_i2s (&ccc->p[0]->id));
+
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                    "Test tries to connect peer %u (`%s') -> peer %u (`%s')\n",
+                    ccc->p[0]->no,
+                    sender_c,
+                    ccc->p[1]->no,
+                    GNUNET_i2s (&ccc->p[1]->id));
+        GNUNET_free (sender_c);
+      }
+      crl->cr = GNUNET_TRANSPORT_TESTING_connect_peers (ccc->p[i],
+                                                        ccc->p[j],
+                                                        &connect_cb,
+                                                        crl);
+    }
+}
+
+
+/**
+ * Function called once we have successfully launched a peer.
+ * Once all peers have been launched, we connect all of them
+ * in a clique.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_TESTING_InternalPeerContext *`
+ */
+static void
+start_cb (void *cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_InternalPeerContext *ipi = cls;
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc = ipi->ccc;
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p = ccc->p[ipi->off];
+
+  ccc->started++;
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Peer %u (`%s') started\n",
+              p->no,
+              GNUNET_i2s (&p->id));
+  if (ccc->started != ccc->num_peers)
+    return;
+  if (NULL != ccc->pre_connect_task)
+  {
+    /* Run the custom per-connect job, then give it a second to
+       go into effect before we continue connecting peers. */
+    ccc->pre_connect_task (ccc->pre_connect_task_cls);
+    ccc->connect_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                                      &do_connect,
+                                                      ccc);
+  }
+  else
+  {
+    do_connect (ccc);
+  }
+}
+
+
+/**
+ * Function run from #GNUNET_TRANSPORT_TESTING_connect_check
+ * once the scheduler is up.  Should launch the peers and
+ * then in the continuations try to connect them.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *`
+ * @param args ignored
+ * @param cfgfile ignored
+ * @param cfg configuration
+ */
+static void
+connect_check_run (void *cls,
+                   char *const *args,
+                   const char *cfgfile,
+                   const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc = cls;
+  int ok;
+
+  ccc->cfg = cfg;
+  ccc->timeout_task = GNUNET_SCHEDULER_add_delayed (ccc->timeout,
+                                                    &do_timeout,
+                                                    ccc);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
+                                 ccc);
+  ok = GNUNET_OK;
+  for (unsigned int i = 0; i < ccc->num_peers; i++)
+  {
+    struct GNUNET_MQ_MessageHandler handlers[] = {
+      GNUNET_MQ_hd_var_size (test,
+                             GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE,
+                             struct GNUNET_TRANSPORT_TESTING_TestMessage,
+                             NULL),
+      GNUNET_MQ_hd_var_size (test2,
+                             GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE2,
+                             struct GNUNET_TRANSPORT_TESTING_TestMessage,
+                             NULL),
+      GNUNET_MQ_handler_end ()
+    };
+    ccc->p[i] = GNUNET_TRANSPORT_TESTING_start_peer (ccc->tth,
+                                                     ccc->cfg_files[i],
+                                                     i + 1,
+                                                     handlers,
+                                                     &my_nc,
+                                                     &my_nd,
+                                                     &ccc->ip[i],
+                                                     &start_cb,
+                                                     &ccc->ip[i]);
+    if (NULL == ccc->p[i])
+      ok = GNUNET_SYSERR;
+  }
+  if (GNUNET_OK != ok)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Fail! Could not start peers!\n");
+    GNUNET_SCHEDULER_shutdown ();
+  }
+}
+
+
+/**
+ * Common implementation of the #GNUNET_TRANSPORT_TESTING_CheckCallback.
+ * Starts and connects the two peers, then invokes the
+ * `connect_continuation` from @a cls.  Sets up a timeout to
+ * abort the test, and a shutdown handler to clean up properly
+ * on exit.
+ *
+ * @param cls closure of type `struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext`
+ * @param tth_ initialized testing handle
+ * @param test_plugin_ name of the plugin
+ * @param test_name_ name of the test
+ * @param num_peers number of entries in the @a cfg_file array
+ * @param cfg_files array of names of configuration files for the peers
+ * @return #GNUNET_SYSERR on error
+ */
+int
+GNUNET_TRANSPORT_TESTING_connect_check (void *cls,
+                                        struct GNUNET_TRANSPORT_TESTING_Handle *
+                                        tth_,
+                                        const char *test_plugin_,
+                                        const char *test_name_,
+                                        unsigned int num_peers,
+                                        char *cfg_files[])
+{
+  static struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_OPTION_END
+  };
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc = cls;
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p[num_peers];
+  struct GNUNET_TRANSPORT_TESTING_InternalPeerContext ip[num_peers];
+  char *argv[] = {
+    (char *) test_name_,
+    "-c",
+    (char *) ccc->config_file,
+    NULL
+  };
+
+  ccc->num_peers = num_peers;
+  ccc->cfg_files = cfg_files;
+  ccc->test_plugin = test_plugin_;
+  ccc->test_name = test_name_;
+  ccc->tth = tth_;
+  ccc->global_ret = GNUNET_OK;
+  ccc->p = p;
+  ccc->ip = ip;
+  for (unsigned int i = 0; i < num_peers; i++)
+  {
+    ip[i].off = i;
+    ip[i].ccc = ccc;
+  }
+  if (GNUNET_OK !=
+      GNUNET_PROGRAM_run ((sizeof(argv) / sizeof(char *)) - 1,
+                          argv,
+                          test_name_,
+                          "nohelp",
+                          options,
+                          &connect_check_run,
+                          ccc))
+    return GNUNET_SYSERR;
+  return ccc->global_ret;
+}
+
+
+/**
+ * Setup testcase.  Calls @a check with the data the test needs.
+ *
+ * @param argv0 binary name (argv[0])
+ * @param filename source file name (__FILE__)
+ * @param num_peers number of peers to start
+ * @param check main function to run
+ * @param check_cls closure for @a check
+ * @return #GNUNET_OK on success
+ */
+int
+GNUNET_TRANSPORT_TESTING_main_ (const char *argv0,
+                                const char *filename,
+                                unsigned int num_peers,
+                                GNUNET_TRANSPORT_TESTING_CheckCallback check,
+                                void *check_cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth;
+  char *test_name;
+  char *test_source;
+  char *test_plugin;
+  char *cfg_names[num_peers];
+  int ret;
+
+  ret = GNUNET_OK;
+  test_name = GNUNET_TRANSPORT_TESTING_get_test_name (argv0);
+  GNUNET_log_setup (test_name,
+                    "WARNING",
+                    NULL);
+  test_source = GNUNET_TRANSPORT_TESTING_get_test_source_name (filename);
+  test_plugin = GNUNET_TRANSPORT_TESTING_get_test_plugin_name (argv0,
+                                                               test_source);
+  for (unsigned int i = 0; i < num_peers; i++)
+    cfg_names[i] = GNUNET_TRANSPORT_TESTING_get_config_name (argv0,
+                                                             i + 1);
+  tth = GNUNET_TRANSPORT_TESTING_init ();
+  if (NULL == tth)
+  {
+    ret = GNUNET_SYSERR;
+  }
+  else
+  {
+    ret = check (check_cls,
+                 tth,
+                 test_plugin,
+                 test_name,
+                 num_peers,
+                 cfg_names);
+    GNUNET_TRANSPORT_TESTING_done (tth);
+  }
+  for (unsigned int i = 0; i < num_peers; i++)
+    GNUNET_free (cfg_names[i]);
+  GNUNET_free (test_source);
+  GNUNET_free (test_plugin);
+  GNUNET_free (test_name);
+  return ret;
+}
+
+
+/* end of transport-testing-main.c */
diff --git a/src/service/transport/transport-testing-send2.c b/src/service/transport/transport-testing-send2.c
new file mode 100644
index 000000000..c48dc3a4a
--- /dev/null
+++ b/src/service/transport/transport-testing-send2.c
@@ -0,0 +1,241 @@
+/*
+     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 transport-testing-send.c
+ * @brief convenience transmission function for tests
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "transport-testing2.h"
+
+/**
+ * Acceptable transmission delay.
+ */
+#define TIMEOUT_TRANSMIT GNUNET_TIME_relative_multiply ( \
+    GNUNET_TIME_UNIT_SECONDS, 30)
+
+
+/**
+ * Return @a cx in @a cls.
+ */
+static void
+find_cr (void *cls,
+         struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
+{
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest **cr = cls;
+
+  if (GNUNET_NO == cx->connected)
+    return;
+  *cr = cx;
+}
+
+
+/**
+ * Send a test message of type @a mtype and size @a msize from
+ * peer @a sender to peer @a receiver.  The peers should be
+ * connected when this function is called.
+ *
+ * @param sender the sending peer
+ * @param receiver the receiving peer
+ * @param mtype message type to use
+ * @param msize size of the message, at least `sizeof (struct GNUNET_TRANSPORT_TESTING_TestMessage)`
+ * @param num unique message number
+ * @param cont continuation to call after transmission
+ * @param cont_cls closure for @a cont
+ * @return #GNUNET_OK if message was queued,
+ *         #GNUNET_NO if peers are not connected
+ *         #GNUNET_SYSERR if @a msize is illegal
+ */
+int
+GNUNET_TRANSPORT_TESTING_send (struct
+                               GNUNET_TRANSPORT_TESTING_PeerContext *sender,
+                               struct GNUNET_TRANSPORT_TESTING_PeerContext *
+                               receiver,
+                               uint16_t mtype,
+                               uint16_t msize,
+                               uint32_t num,
+                               GNUNET_SCHEDULER_TaskCallback cont,
+                               void *cont_cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cr;
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_TRANSPORT_TESTING_TestMessage *test;
+
+  if (msize < sizeof(struct GNUNET_TRANSPORT_TESTING_TestMessage))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  cr = NULL;
+  GNUNET_TRANSPORT_TESTING_find_connecting_context (sender,
+                                                    receiver,
+                                                    &find_cr,
+                                                    &cr);
+  if (NULL == cr)
+    GNUNET_TRANSPORT_TESTING_find_connecting_context (receiver,
+                                                      sender,
+                                                      &find_cr,
+                                                      &cr);
+  if (NULL == cr)
+  {
+    GNUNET_break (0);
+    return GNUNET_NO;
+  }
+  if (NULL == cr->mq)
+  {
+    GNUNET_break (0);
+    return GNUNET_NO;
+  }
+  {
+    char *receiver_s = GNUNET_strdup (GNUNET_i2s (&receiver->id));
+
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Sending message from peer %u (`%s') -> peer %u (`%s') !\n",
+                sender->no,
+                GNUNET_i2s (&sender->id),
+                receiver->no,
+                receiver_s);
+    GNUNET_free (receiver_s);
+  }
+  env = GNUNET_MQ_msg_extra (test,
+                             msize - sizeof(*test),
+                             mtype);
+  test->num = htonl (num);
+  memset (&test[1],
+          num,
+          msize - sizeof(*test));
+  GNUNET_MQ_notify_sent (env,
+                         cont,
+                         cont_cls);
+  GNUNET_MQ_send (cr->mq,
+                  env);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Task that sends a test message from the
+ * first peer to the second peer.
+ *
+ * @param ccc context which should contain at least two peers, the
+ *        first two of which should be currently connected
+ * @param size desired message size
+ * @param cont continuation to call after transmission
+ * @param cont_cls closure for @a cont
+ */
+static void
+do_send (struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc,
+         uint16_t size,
+         GNUNET_SCHEDULER_TaskCallback cont,
+         void *cont_cls)
+{
+  int ret;
+
+  ccc->global_ret = GNUNET_SYSERR;
+  ret = GNUNET_TRANSPORT_TESTING_send (ccc->p[0],
+                                       ccc->p[1],
+                                       GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE,
+                                       size,
+                                       ccc->send_num_gen++,
+                                       cont,
+                                       cont_cls);
+  GNUNET_assert (GNUNET_SYSERR != ret);
+  if (GNUNET_NO == ret)
+  {
+    GNUNET_break (0);
+    ccc->global_ret = GNUNET_SYSERR;
+    GNUNET_SCHEDULER_shutdown ();
+  }
+}
+
+
+/**
+ * Task that sends a minimalistic test message from the
+ * first peer to the second peer.
+ *
+ * @param cls the `struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext`
+ *        which should contain at least two peers, the first two
+ *        of which should be currently connected
+ */
+void
+GNUNET_TRANSPORT_TESTING_simple_send (void *cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_SendClosure *sc = cls;
+  int done;
+  size_t msize;
+
+  if (0 < sc->num_messages)
+  {
+    sc->num_messages--;
+    done = (0 == sc->num_messages);
+  }
+  else
+  {
+    done = 0;   /* infinite loop */
+  }
+  msize = sizeof(struct GNUNET_TRANSPORT_TESTING_TestMessage);
+  if (NULL != sc->get_size_cb)
+    msize = sc->get_size_cb (sc->num_messages);
+  /* if this was the last message, call the continuation,
+     otherwise call this function again */
+  do_send (sc->ccc,
+           msize,
+           done ? sc->cont : &GNUNET_TRANSPORT_TESTING_simple_send,
+           done ? sc->cont_cls : sc);
+}
+
+
+/**
+ * Task that sends a large test message from the
+ * first peer to the second peer.
+ *
+ * @param cls the `struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext`
+ *        which should contain at least two peers, the first two
+ *        of which should be currently connected
+ */
+void
+GNUNET_TRANSPORT_TESTING_large_send (void *cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_SendClosure *sc = cls;
+  int done;
+  size_t msize;
+
+  if (0 < sc->num_messages)
+  {
+    sc->num_messages--;
+    done = (0 == sc->num_messages);
+  }
+  else
+  {
+    done = 0;   /* infinite loop */
+  }
+  msize = 2600;
+  if (NULL != sc->get_size_cb)
+    msize = sc->get_size_cb (sc->num_messages);
+  /* if this was the last message, call the continuation,
+     otherwise call this function again */
+  do_send (sc->ccc,
+           msize,
+           done ? sc->cont : &GNUNET_TRANSPORT_TESTING_large_send,
+           done ? sc->cont_cls : sc);
+}
+
+
+/* end of transport-testing-send.c */
diff --git a/src/service/transport/transport-testing2.c b/src/service/transport/transport-testing2.c
new file mode 100644
index 000000000..877730630
--- /dev/null
+++ b/src/service/transport/transport-testing2.c
@@ -0,0 +1,871 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2006, 2009, 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 transport-testing.c
+ * @brief testing lib for transport service
+ * @author Matthias Wachs
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "transport-testing2.h"
+
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "transport-testing", __VA_ARGS__)
+
+
+static struct GNUNET_TRANSPORT_TESTING_PeerContext *
+find_peer_context (struct GNUNET_TRANSPORT_TESTING_Handle *tth,
+                   const struct GNUNET_PeerIdentity *peer)
+{
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *t;
+
+  for (t = tth->p_head; NULL != t; t = t->next)
+    if (0 == memcmp (&t->id,
+                     peer,
+                     sizeof(struct GNUNET_PeerIdentity)))
+      return t;
+  return NULL;
+}
+
+
+/**
+ * Find any connecting context matching the given pair of peers.
+ *
+ * @param p1 first peer
+ * @param p2 second peer
+ * @param cb function to call
+ * @param cb_cls closure for @a cb
+ */
+void
+GNUNET_TRANSPORT_TESTING_find_connecting_context (struct
+                                                  GNUNET_TRANSPORT_TESTING_PeerContext
+                                                  *p1,
+                                                  struct
+                                                  GNUNET_TRANSPORT_TESTING_PeerContext
+                                                  *p2,
+                                                  GNUNET_TRANSPORT_TESTING_ConnectContextCallback
+                                                  cb,
+                                                  void *cb_cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p1->tth;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ccn;
+
+  for (cc = tth->cc_head; NULL != cc; cc = ccn)
+  {
+    ccn = cc->next;
+    if ((cc->p1 == p1) &&
+        (cc->p2 == p2))
+      cb (cb_cls,
+          cc);
+  }
+}
+
+
+static void
+set_p1c (void *cls,
+         struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
+{
+  int *found = cls;
+
+  if (NULL != found)
+    *found = GNUNET_YES;
+  cx->p1_c = GNUNET_YES;
+}
+
+
+static void
+set_mq (void *cls,
+        struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
+{
+  struct GNUNET_MQ_Handle *mq = cls;
+
+  cx->mq = mq;
+}
+
+
+static void
+set_p2c (void *cls,
+         struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
+{
+  int *found = cls;
+
+  if (NULL != found)
+    *found = GNUNET_YES;
+  cx->p2_c = GNUNET_YES;
+}
+
+
+static void
+clear_p1c (void *cls,
+           struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
+{
+  int *found = cls;
+
+  if (NULL != found)
+    *found = GNUNET_YES;
+  cx->p1_c = GNUNET_NO;
+}
+
+
+static void
+clear_p2c (void *cls,
+           struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
+{
+  int *found = cls;
+
+  if (NULL != found)
+    *found = GNUNET_YES;
+  cx->p2_c = GNUNET_NO;
+}
+
+
+static void *
+notify_connect (void *cls,
+                const struct GNUNET_PeerIdentity *peer,
+                struct GNUNET_MQ_Handle *mq)
+{
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls;
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
+  char *p2_s;
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p2;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ccn;
+  int found;
+  void *ret;
+
+  p2 = find_peer_context (p->tth,
+                          peer);
+  if (NULL != p->nc)
+    ret = p->nc (p->cb_cls,
+                 peer,
+                 mq);
+  else
+    ret = NULL;
+
+  if (NULL != p2)
+    GNUNET_asprintf (&p2_s,
+                     "%u (`%s')",
+                     p2->no,
+                     GNUNET_i2s (&p2->id));
+  else
+    GNUNET_asprintf (&p2_s,
+                     "`%s'",
+                     GNUNET_i2s (peer));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Peers %s connected to peer %u (`%s')\n",
+       p2_s,
+       p->no,
+       GNUNET_i2s (&p->id));
+  GNUNET_free (p2_s);
+  /* update flags in connecting contexts */
+  found = GNUNET_NO;
+  GNUNET_TRANSPORT_TESTING_find_connecting_context (p,
+                                                    p2,
+                                                    &set_p1c,
+                                                    &found);
+  if (GNUNET_NO == found)
+  {
+    cc = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_ConnectRequest);
+    cc->p1 = p;
+    cc->p2 = p2;
+    cc->p1_c = GNUNET_YES;
+    GNUNET_CONTAINER_DLL_insert (tth->cc_head,
+                                 tth->cc_tail,
+                                 cc);
+  }
+  found = GNUNET_NO;
+  GNUNET_TRANSPORT_TESTING_find_connecting_context (p2,
+                                                    p,
+                                                    &set_p2c,
+                                                    &found);
+  if (GNUNET_NO == found)
+  {
+    cc = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_ConnectRequest);
+    cc->p1 = p2;
+    cc->p2 = p;
+    cc->p1_c = GNUNET_YES;
+    GNUNET_CONTAINER_DLL_insert (tth->cc_head,
+                                 tth->cc_tail,
+                                 cc);
+  }
+  GNUNET_TRANSPORT_TESTING_find_connecting_context (p,
+                                                    p2,
+                                                    &set_mq,
+                                                    mq);
+  /* update set connected flag for all requests */
+  for (cc = tth->cc_head; NULL != cc; cc = cc->next)
+  {
+    if (GNUNET_YES == cc->connected)
+      continue;
+    if ((GNUNET_YES == cc->p1_c) &&
+        (GNUNET_YES == cc->p2_c))
+    {
+      cc->connected = GNUNET_YES;
+      /* stop trying to connect */
+      if (NULL != cc->tct)
+      {
+        GNUNET_SCHEDULER_cancel (cc->tct);
+        cc->tct = NULL;
+      }
+      if (NULL != cc->ah_sh)
+      {
+        GNUNET_TRANSPORT_application_suggest_cancel (cc->ah_sh);
+        cc->ah_sh = NULL;
+      }
+    }
+  }
+  /* then notify application */
+  for (cc = tth->cc_head; NULL != cc; cc = ccn)
+  {
+    ccn = cc->next;
+    if ((GNUNET_YES == cc->connected) &&
+        (NULL != cc->cb))
+    {
+      cc->cb (cc->cb_cls);
+      cc->cb = NULL;     /* only notify once! */
+    }
+  }
+  return ret;
+}
+
+
+static void
+notify_disconnect (void *cls,
+                   const struct GNUNET_PeerIdentity *peer,
+                   void *handler_cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls;
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
+  char *p2_s;
+  /* Find PeerContext */
+  int no = 0;
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p2 = NULL;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
+
+  p2 = find_peer_context (p->tth,
+                          peer);
+  no = p->no;
+  if (NULL != p2)
+    GNUNET_asprintf (&p2_s,
+                     "%u (`%s')",
+                     p2->no,
+                     GNUNET_i2s (&p2->id));
+  else
+    GNUNET_asprintf (&p2_s,
+                     "`%s'",
+                     GNUNET_i2s (peer));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Peers %s disconnected from peer %u (`%s')\n",
+       p2_s,
+       no,
+       GNUNET_i2s (&p->id));
+  GNUNET_free (p2_s);
+  /* notify about disconnect */
+  if (NULL != p->nd)
+    p->nd (p->cb_cls,
+           peer,
+           handler_cls);
+  if (NULL == p2)
+    return;
+  /* clear MQ, it is now invalid */
+  GNUNET_TRANSPORT_TESTING_find_connecting_context (p,
+                                                    p2,
+                                                    &set_mq,
+                                                    NULL);
+  /* update set connected flags for all requests */
+  GNUNET_TRANSPORT_TESTING_find_connecting_context (p,
+                                                    p2,
+                                                    &clear_p1c,
+                                                    NULL);
+  GNUNET_TRANSPORT_TESTING_find_connecting_context (p2,
+                                                    p,
+                                                    &clear_p2c,
+                                                    NULL);
+  /* resume connectivity requests as necessary */
+  for (cc = tth->cc_head; NULL != cc; cc = cc->next)
+  {
+    if (GNUNET_NO == cc->connected)
+      continue;
+    if ((GNUNET_YES != cc->p1_c) ||
+        (GNUNET_YES != cc->p2_c))
+    {
+      cc->connected = GNUNET_NO;
+      /* start trying to connect */
+      if (NULL == cc->ah_sh)
+        cc->ah_sh = GNUNET_TRANSPORT_application_suggest (cc->p1->ah,
+                                                          &p2->id,
+                                                          GNUNET_MQ_PRIO_BEST_EFFORT,
+                                                          GNUNET_BANDWIDTH_ZERO);
+    }
+  }
+}
+
+
+static void
+retrieve_hello (void *cls);
+
+static void
+hello_iter_cb (void *cb_cls,
+               const struct GNUNET_PEERSTORE_Record *record,
+               const char *emsg)
+{
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cb_cls;
+  if (NULL == record)
+  {
+    p->pic = NULL;
+    if (NULL != p->start_cb)
+      p->rh_task = GNUNET_SCHEDULER_add_now (retrieve_hello, p);
+    return;
+  }
+  // Check record type et al?
+  p->hello_size = record->value_size;
+  p->hello = GNUNET_malloc (p->hello_size);
+  memcpy (p->hello, record->value, p->hello_size);
+  p->hello[p->hello_size - 1] = '\0';
+
+  GNUNET_PEERSTORE_iteration_stop (p->pic);
+  p->pic = NULL;
+  if (NULL != p->start_cb)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Peer %u (`%s') successfully started\n",
+         p->no,
+         GNUNET_i2s (&p->id));
+    p->start_cb (p->start_cb_cls);
+    p->start_cb = NULL;
+  }
+}
+
+
+static void
+retrieve_hello (void *cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls;
+  p->rh_task = NULL;
+  p->pic = GNUNET_PEERSTORE_iteration_start (p->ph,
+                                           "transport",
+                                           &p->id,
+                                           GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY,
+                                           hello_iter_cb,
+                                           p);
+
+}
+
+
+struct GNUNET_TRANSPORT_TESTING_PeerContext *
+GNUNET_TRANSPORT_TESTING_start_peer (struct
+                                     GNUNET_TRANSPORT_TESTING_Handle *tth,
+                                     const char *cfgname,
+                                     int peer_id,
+                                     const struct
+                                     GNUNET_MQ_MessageHandler *handlers,
+                                     GNUNET_TRANSPORT_NotifyConnect nc,
+                                     GNUNET_TRANSPORT_NotifyDisconnect nd,
+                                     void *cb_cls,
+                                     GNUNET_SCHEDULER_TaskCallback start_cb,
+                                     void *start_cb_cls)
+{
+  char *emsg = NULL;
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p;
+  struct GNUNET_PeerIdentity dummy;
+  unsigned int i;
+
+  if (GNUNET_NO == GNUNET_DISK_file_test (cfgname))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "File not found: `%s'\n",
+         cfgname);
+    return NULL;
+  }
+
+  p = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_PeerContext);
+  p->tth = tth;
+  p->nc = nc;
+  p->nd = nd;
+  if (NULL != handlers)
+  {
+    for (i = 0; NULL != handlers[i].cb; i++)
+      ;
+    p->handlers = GNUNET_new_array (i + 1,
+                                    struct GNUNET_MQ_MessageHandler);
+    GNUNET_memcpy (p->handlers,
+                   handlers,
+                   i * sizeof(struct GNUNET_MQ_MessageHandler));
+  }
+  if (NULL != cb_cls)
+    p->cb_cls = cb_cls;
+  else
+    p->cb_cls = p;
+  p->start_cb = start_cb;
+  if (NULL != start_cb_cls)
+    p->start_cb_cls = start_cb_cls;
+  else
+    p->start_cb_cls = p;
+  GNUNET_CONTAINER_DLL_insert (tth->p_head,
+                               tth->p_tail,
+                               p);
+
+  /* Create configuration and call testing lib to modify it */
+  p->cfg = GNUNET_CONFIGURATION_create ();
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_load (p->cfg, cfgname));
+  if (GNUNET_SYSERR ==
+      GNUNET_TESTING_configuration_create (tth->tl_system,
+                                           p->cfg))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Testing library failed to create unique configuration based on `%s'\n",
+         cfgname);
+    GNUNET_CONFIGURATION_destroy (p->cfg);
+    GNUNET_free (p);
+    return NULL;
+  }
+
+  p->no = peer_id;
+  /* Configure peer with configuration */
+  p->peer = GNUNET_TESTING_peer_configure (tth->tl_system,
+                                           p->cfg,
+                                           p->no,
+                                           NULL,
+                                           &emsg);
+  if (NULL == p->peer)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Testing library failed to create unique configuration based on `%s': `%s'\n",
+         cfgname,
+         emsg);
+    GNUNET_TRANSPORT_TESTING_stop_peer (p);
+    GNUNET_free (emsg);
+    return NULL;
+  }
+
+  if (GNUNET_OK != GNUNET_TESTING_peer_start (p->peer))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Testing library failed to create unique configuration based on `%s'\n",
+         cfgname);
+    GNUNET_TRANSPORT_TESTING_stop_peer (p);
+    return NULL;
+  }
+
+  memset (&dummy,
+          '\0',
+          sizeof(dummy));
+  GNUNET_TESTING_peer_get_identity (p->peer,
+                                    &p->id);
+  if (0 == memcmp (&dummy,
+                   &p->id,
+                   sizeof(struct GNUNET_PeerIdentity)))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Testing library failed to obtain peer identity for peer %u\n",
+         p->no);
+    GNUNET_TRANSPORT_TESTING_stop_peer (p);
+    return NULL;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Peer %u configured with identity `%s'\n",
+       p->no,
+       GNUNET_i2s_full (&p->id));
+  p->th = GNUNET_TRANSPORT_core_connect (p->cfg,
+                                         NULL,
+                                         handlers,
+                                         p,
+                                         &notify_connect,
+                                         &notify_disconnect);
+  if (NULL == p->th)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Failed to connect to transport service for peer `%s': `%s'\n",
+         cfgname,
+         emsg);
+    GNUNET_TRANSPORT_TESTING_stop_peer (p);
+    GNUNET_free (emsg);
+    return NULL;
+  }
+  p->ah = GNUNET_TRANSPORT_application_init (p->cfg);
+  if (NULL == p->ah)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Failed to connect to TNG service for peer `%s': `%s'\n",
+         cfgname,
+         emsg);
+    GNUNET_TRANSPORT_TESTING_stop_peer (p);
+    GNUNET_free (emsg);
+    return NULL;
+  }
+  p->ph = GNUNET_PEERSTORE_connect (p->cfg);
+  // FIXME Error handling
+  p->rh_task = GNUNET_SCHEDULER_add_now (retrieve_hello, p);
+
+  return p;
+}
+
+
+int
+GNUNET_TRANSPORT_TESTING_restart_peer (struct
+                                       GNUNET_TRANSPORT_TESTING_PeerContext *p,
+                                       GNUNET_SCHEDULER_TaskCallback restart_cb,
+                                       void *restart_cb_cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ccn;
+
+  /* shutdown */
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Stopping peer %u (`%s')\n",
+       p->no,
+       GNUNET_i2s (&p->id));
+  if (NULL != p->pic)
+  {
+    GNUNET_PEERSTORE_iteration_stop (p->pic);
+    p->pic = NULL;
+  }
+  if (NULL != p->th)
+  {
+    GNUNET_TRANSPORT_core_disconnect (p->th);
+    p->th = NULL;
+  }
+  for (cc = p->tth->cc_head; NULL != cc; cc = ccn)
+  {
+    ccn = cc->next;
+    if ((cc->p1 == p) ||
+        (cc->p2 == p))
+      GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc);
+  }
+  if (NULL != p->ah)
+  {
+    GNUNET_TRANSPORT_application_done (p->ah);
+    p->ah = NULL;
+  }
+  if (GNUNET_SYSERR ==
+      GNUNET_TESTING_peer_stop (p->peer))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Failed to stop peer %u (`%s')\n",
+         p->no,
+         GNUNET_i2s (&p->id));
+    return GNUNET_SYSERR;
+  }
+
+  sleep (5);  // YUCK!
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Restarting peer %u (`%s')\n",
+       p->no,
+       GNUNET_i2s (&p->id));
+  /* restart */
+  if (GNUNET_SYSERR == GNUNET_TESTING_peer_start (p->peer))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Failed to restart peer %u (`%s')\n",
+         p->no,
+         GNUNET_i2s (&p->id));
+    return GNUNET_SYSERR;
+  }
+
+  GNUNET_assert (NULL == p->start_cb);
+  p->start_cb = restart_cb;
+  p->start_cb_cls = restart_cb_cls;
+
+  p->th = GNUNET_TRANSPORT_core_connect (p->cfg,
+                                         NULL,
+                                         p->handlers,
+                                         p,
+                                         &notify_connect,
+                                         &notify_disconnect);
+  GNUNET_assert (NULL != p->th);
+  p->ah = GNUNET_TRANSPORT_application_init (p->cfg);
+  p->pic = GNUNET_PEERSTORE_iteration_start (p->ph,
+                                           "transport",
+                                           &p->id,
+                                           GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY,
+                                           hello_iter_cb,
+                                           p);
+  GNUNET_assert (NULL != p->pic);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Shutdown the given peer
+ *
+ * @param p the peer
+ */
+void
+GNUNET_TRANSPORT_TESTING_stop_peer (struct
+                                    GNUNET_TRANSPORT_TESTING_PeerContext *p)
+{
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ccn;
+  /* shutdown */
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Stopping peer %u (`%s')\n",
+       p->no,
+       GNUNET_i2s (&p->id));
+
+  for (cc = tth->cc_head; NULL != cc; cc = ccn)
+  {
+    ccn = cc->next;
+    if ((cc->p1 == p) ||
+        (cc->p2 == p))
+      GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc);
+  }
+  if (NULL != p->pic)
+  {
+    GNUNET_PEERSTORE_iteration_stop (p->pic);
+    p->pic = NULL;
+  }
+  if (NULL != p->th)
+  {
+    GNUNET_TRANSPORT_core_disconnect (p->th);
+    p->th = NULL;
+  }
+  if (NULL != p->ah)
+  {
+    GNUNET_TRANSPORT_application_done (p->ah);
+    p->ah = NULL;
+  }
+  if (NULL != p->ph)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Disconnecting from PEERSTORE service\n");
+    GNUNET_PEERSTORE_disconnect (p->ph);
+    p->ph = NULL;
+  }
+
+  if (NULL != p->peer)
+  {
+    if (GNUNET_OK !=
+        GNUNET_TESTING_peer_stop (p->peer))
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Testing lib failed to stop peer %u (`%s')\n",
+           p->no,
+           GNUNET_i2s (&p->id));
+    }
+    GNUNET_TESTING_peer_destroy (p->peer);
+    p->peer = NULL;
+  }
+  if (NULL != p->hello)
+  {
+    GNUNET_free (p->hello);
+    p->hello = NULL;
+  }
+  if (NULL != p->cfg)
+  {
+    GNUNET_CONFIGURATION_destroy (p->cfg);
+    p->cfg = NULL;
+  }
+  if (NULL != p->handlers)
+  {
+    GNUNET_free (p->handlers);
+    p->handlers = NULL;
+  }
+  GNUNET_CONTAINER_DLL_remove (tth->p_head,
+                               tth->p_tail,
+                               p);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Peer %u (`%s') stopped\n",
+       p->no,
+       GNUNET_i2s (&p->id));
+  if (NULL != p->rh_task)
+    GNUNET_SCHEDULER_cancel (p->rh_task);
+  p->rh_task = NULL;
+  GNUNET_free (p);
+}
+
+
+/**
+ * Function called after the HELLO was passed to the
+ * transport service.
+ * FIXME maybe schedule the application_validate somehow
+ */
+/*
+   static void
+   hello_offered (void *cls)
+   {
+   struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc = cls;
+
+   cc->oh = NULL;
+   cc->tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+   &offer_hello,
+   cc);
+   }*/
+
+
+/**
+ * Initiate a connection from p1 to p2 by offering p1 p2's HELLO message
+ *
+ * Remarks: start_peer's notify_connect callback can be called before.
+ *
+ * @param tth transport testing handle
+ * @param p1 peer 1
+ * @param p2 peer 2
+ * @param cb the callback to call when both peers notified that they are connected
+ * @param cls callback cls
+ * @return a connect request handle
+ */
+struct GNUNET_TRANSPORT_TESTING_ConnectRequest *
+GNUNET_TRANSPORT_TESTING_connect_peers (struct
+                                        GNUNET_TRANSPORT_TESTING_PeerContext *p1,
+                                        struct
+                                        GNUNET_TRANSPORT_TESTING_PeerContext *p2,
+                                        GNUNET_SCHEDULER_TaskCallback cb,
+                                        void *cls)
+{
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p1->tth;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ccn;
+
+  ccn = NULL;
+  for (cc = tth->cc_head; NULL != cc; cc = cc->next)
+  {
+    if ((cc->p1 == p1) &&
+        (cc->p2 == p2))
+    {
+      ccn = cc;
+      break;
+    }
+  }
+
+  cc = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_ConnectRequest);
+  cc->p1 = p1;
+  cc->p2 = p2;
+  cc->cb = cb;
+  if (NULL != cls)
+    cc->cb_cls = cls;
+  else
+    cc->cb_cls = cc;
+  if (NULL != ccn)
+  {
+    cc->p1_c = ccn->p1_c;
+    cc->p2_c = ccn->p2_c;
+    cc->connected = ccn->connected;
+  }
+  GNUNET_CONTAINER_DLL_insert (tth->cc_head,
+                               tth->cc_tail,
+                               cc);
+  cc->ah_sh = GNUNET_TRANSPORT_application_suggest (cc->p1->ah,
+                                                    &p2->id,
+                                                    GNUNET_MQ_PRIO_BEST_EFFORT,
+                                                    GNUNET_BANDWIDTH_ZERO);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "New connect request %p\n",
+       cc);
+  return cc;
+}
+
+
+void
+GNUNET_TRANSPORT_TESTING_connect_peers_cancel (struct
+                                               GNUNET_TRANSPORT_TESTING_ConnectRequest
+                                               *cc)
+{
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth = cc->p1->tth;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Canceling connect request!\n");
+  if (NULL != cc->tct)
+  {
+    GNUNET_SCHEDULER_cancel (cc->tct);
+    cc->tct = NULL;
+  }
+  if (NULL != cc->ah_sh)
+  {
+    GNUNET_TRANSPORT_application_suggest_cancel (cc->ah_sh);
+    cc->ah_sh = NULL;
+  }
+  GNUNET_CONTAINER_DLL_remove (tth->cc_head,
+                               tth->cc_tail,
+                               cc);
+  GNUNET_free (cc);
+}
+
+
+/**
+ * Clean up the transport testing
+ *
+ * @param tth transport testing handle
+ */
+void
+GNUNET_TRANSPORT_TESTING_done (struct GNUNET_TRANSPORT_TESTING_Handle *tth)
+{
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ct;
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p;
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *t;
+
+  if (NULL == tth)
+    return;
+  cc = tth->cc_head;
+  while (NULL != cc)
+  {
+    ct = cc->next;
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Developer forgot to cancel connect request!\n");
+    GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc);
+    cc = ct;
+  }
+  p = tth->p_head;
+  while (NULL != p)
+  {
+    t = p->next;
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Developer forgot to stop peer!\n");
+    GNUNET_TRANSPORT_TESTING_stop_peer (p);
+    p = t;
+  }
+  GNUNET_TESTING_system_destroy (tth->tl_system,
+                                 GNUNET_YES);
+
+  GNUNET_free (tth);
+}
+
+
+/**
+ * Initialize the transport testing
+ *
+ * @return transport testing handle
+ */
+struct GNUNET_TRANSPORT_TESTING_Handle *
+GNUNET_TRANSPORT_TESTING_init ()
+{
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth;
+
+  tth = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_Handle);
+  tth->tl_system = GNUNET_TESTING_system_create ("transport-testing",
+                                                 NULL,
+                                                 NULL,
+                                                 NULL);
+  if (NULL == tth->tl_system)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to initialize testing library!\n");
+    GNUNET_free (tth);
+    return NULL;
+  }
+  return tth;
+}
+
+
+/* end of transport-testing.c */
diff --git a/src/service/transport/transport-testing2.h b/src/service/transport/transport-testing2.h
new file mode 100644
index 000000000..42ffce3f2
--- /dev/null
+++ b/src/service/transport/transport-testing2.h
@@ -0,0 +1,940 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2006, 2009, 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 transport-testing.h
+ * @brief testing lib for transport service
+ * @author Matthias Wachs
+ * @author Christian Grothoff
+ */
+#ifndef TRANSPORT_TESTING_H
+#define TRANSPORT_TESTING_H
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_peerstore_service.h"
+#include "gnunet_transport_core_service.h"
+#include "gnunet_transport_application_service.h"
+#include "gnunet_testing_lib.h"
+
+
+/* ************* Basic functions for starting/stopping/connecting *********** */
+
+/**
+ * Context for a single peer
+ */
+struct GNUNET_TRANSPORT_TESTING_PeerContext;
+
+/**
+ * Definition for a transport testing handle
+ */
+struct GNUNET_TRANSPORT_TESTING_Handle;
+
+
+/**
+ * Context for a single peer
+ */
+struct GNUNET_TRANSPORT_TESTING_PeerContext
+{
+  /**
+   * Next element in the DLL
+   */
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *next;
+
+  /**
+   * Previous element in the DLL
+   */
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *prev;
+
+  /**
+   * Transport testing handle this peer belongs to
+   */
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth;
+
+  /**
+   * Application handle
+   */
+  struct GNUNET_TRANSPORT_ApplicationHandle *ah;
+
+  /**
+   * Peer's configuration
+   */
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Peer's transport service handle
+   */
+  struct GNUNET_TRANSPORT_CoreHandle *th;
+
+  /**
+   * Peer's PEERSTORE Handle
+   */
+  struct GNUNET_PEERSTORE_Handle *ph;
+
+  /**
+   * Peer's transport get hello handle to retrieve peer's HELLO message
+   */
+  struct GNUNET_PEERSTORE_IterateContext *pic;
+
+  /**
+   * Hello
+   */
+  char *hello;
+
+  /**
+   * Hello size
+   */
+  size_t hello_size;
+
+  /**
+   * Peer's testing handle
+   */
+  struct GNUNET_TESTING_Peer *peer;
+
+  /**
+   * Peer identity
+   */
+  struct GNUNET_PeerIdentity id;
+
+  /**
+   * Handle for the peer's ARM process
+   */
+  struct GNUNET_OS_Process *arm_proc;
+
+  /**
+   * Receive callback
+   */
+  struct GNUNET_MQ_MessageHandler *handlers;
+
+  /**
+   * Notify connect callback
+   */
+  GNUNET_TRANSPORT_NotifyConnect nc;
+
+  /**
+   * Notify disconnect callback
+   */
+  GNUNET_TRANSPORT_NotifyDisconnect nd;
+
+  /**
+   * Startup completed callback
+   */
+  GNUNET_SCHEDULER_TaskCallback start_cb;
+
+  /**
+   * Hello get task
+   */
+  struct GNUNET_SCHEDULER_Task *rh_task;
+
+  /**
+   * Closure for the @a nc and @a nd callbacks
+   */
+  void *cb_cls;
+
+  /**
+   * Closure for @e start_cb.
+   */
+  void *start_cb_cls;
+
+  /**
+   * An unique number to identify the peer
+   */
+  unsigned int no;
+};
+
+
+/**
+ * Handle for a request to connect two peers.
+ */
+struct GNUNET_TRANSPORT_TESTING_ConnectRequest
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *prev;
+
+  /**
+   * Peer we want to connect.
+   */
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p1;
+
+  /**
+   * Peer we want to connect.
+   */
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p2;
+
+  /**
+   * Task by which we accomplish the connection.
+   */
+  struct GNUNET_SCHEDULER_Task *tct;
+
+  /**
+   * Handle by which we ask TNG to facilitate the connection.
+   */
+  struct GNUNET_TRANSPORT_ApplicationSuggestHandle *ah_sh;
+
+  /**
+   * Function to call upon completion.
+   */
+  GNUNET_SCHEDULER_TaskCallback cb;
+
+  /**
+   * Closure for @e cb.
+   */
+  void *cb_cls;
+
+  /**
+   * Message queue for sending from @a p1 to @a p2.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Set if peer1 says the connection is up to peer2.
+   */
+  int p1_c;
+
+  /**
+   * Set if peer2 says the connection is up to peer1.
+   */
+  int p2_c;
+
+  /**
+   * #GNUNET_YES if both @e p1_c and @e p2_c are #GNUNET_YES.
+   */
+  int connected;
+};
+
+
+/**
+ * Handle for a test run.
+ */
+struct GNUNET_TRANSPORT_TESTING_Handle
+{
+  /**
+   * Testing library system handle
+   */
+  struct GNUNET_TESTBED_System *tl_system;
+
+  /**
+   * head DLL of connect contexts
+   */
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc_head;
+
+  /**
+   * head DLL of connect contexts
+   */
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc_tail;
+
+  /**
+   * head DLL of peers
+   */
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p_head;
+
+  /**
+   * tail DLL of peers
+   */
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p_tail;
+};
+
+
+/**
+ * Initialize the transport testing
+ *
+ * @return transport testing handle
+ */
+struct GNUNET_TRANSPORT_TESTING_Handle *
+GNUNET_TRANSPORT_TESTING_init (void);
+
+
+/**
+ * Clean up the transport testing
+ *
+ * @param tth transport testing handle
+ */
+void
+GNUNET_TRANSPORT_TESTING_done (struct GNUNET_TRANSPORT_TESTING_Handle *tth);
+
+
+/**
+ * Start a peer with the given configuration
+ *
+ * @param tth the testing handle
+ * @param cfgname configuration file
+ * @param peer_id an identification number for the peer
+ * @param handlers functions for receiving messages
+ * @param nc connect callback
+ * @param nd disconnect callback
+ * @param cb_cls closure for @a nc and @a nd callback
+ * @param start_cb start callback
+ * @param start_cb_cls closure for @a start_cb
+ * @return the peer context
+ */
+struct GNUNET_TRANSPORT_TESTING_PeerContext *
+GNUNET_TRANSPORT_TESTING_start_peer (
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth,
+  const char *cfgname,
+  int peer_id,
+  const struct GNUNET_MQ_MessageHandler *handlers,
+  GNUNET_TRANSPORT_NotifyConnect nc,
+  GNUNET_TRANSPORT_NotifyDisconnect nd,
+  void *cb_cls,
+  GNUNET_SCHEDULER_TaskCallback start_cb,
+  void *start_cb_cls);
+
+
+/**
+ * Shutdown the given peer
+ *
+ * @param p the peer
+ */
+void
+GNUNET_TRANSPORT_TESTING_stop_peer (
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *pc);
+
+
+/**
+ * Stops and restarts the given peer, sleeping (!) for 5s in between.
+ *
+ * @param p the peer
+ * @param restart_cb restart callback
+ * @param restart_cb_cls callback closure
+ * @return #GNUNET_OK in success otherwise #GNUNET_SYSERR
+ */
+int
+GNUNET_TRANSPORT_TESTING_restart_peer (
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p,
+  GNUNET_SCHEDULER_TaskCallback restart_cb,
+  void *restart_cb_cls);
+
+
+/**
+ * Connect the given peers and call the callback when both peers
+ * report the inbound connection. Remarks: start_peer's notify_connect
+ * callback can be called before.
+ *
+ * @param p1 peer 1
+ * @param p2 peer 2
+ * @param cb the callback to call when both peers notified that they are
+ * connected
+ * @param cls callback cls
+ * @return a connect request handle
+ */
+struct GNUNET_TRANSPORT_TESTING_ConnectRequest *
+GNUNET_TRANSPORT_TESTING_connect_peers (
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p1,
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p2,
+  GNUNET_SCHEDULER_TaskCallback cb,
+  void *cls);
+
+
+/**
+ * Cancel the request to connect two peers.  You MUST cancel the
+ * request if you stop the peers before the peers connected
+ * successfully.
+ *
+ * @param cc a connect request handle
+ */
+void
+GNUNET_TRANSPORT_TESTING_connect_peers_cancel (
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc);
+
+
+/**
+ * Function called on matching connect requests.
+ *
+ * @param cls closure
+ * @param cc request matching the query
+ */
+typedef void (*GNUNET_TRANSPORT_TESTING_ConnectContextCallback) (
+  void *cls,
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc);
+
+
+/**
+ * Find any connecting context matching the given pair of peers.
+ *
+ * @param p1 first peer
+ * @param p2 second peer
+ * @param cb function to call
+ * @param cb_cls closure for @a cb
+ */
+void
+GNUNET_TRANSPORT_TESTING_find_connecting_context (
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p1,
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p2,
+  GNUNET_TRANSPORT_TESTING_ConnectContextCallback cb,
+  void *cb_cls);
+
+
+/* ********************** high-level process functions *************** */
+
+
+/**
+ * Function called once the peers have been launched and
+ * connected by #GNUNET_TRANSPORT_TESTING_connect_check().
+ *
+ * @param cls closure
+ * @param num_peers size of the @a p array
+ * @param p the peers that were launched
+ */
+typedef void (*GNUNET_TRANSPORT_TESTING_ConnectContinuation) (
+  void *cls,
+  unsigned int num_peers,
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p[]);
+
+
+/**
+ * Internal data structure.
+ */
+struct GNUNET_TRANSPORT_TESTING_ConnectRequestList;
+
+/**
+ * Internal data structure.
+ */
+struct GNUNET_TRANSPORT_TESTING_InternalPeerContext;
+
+
+GNUNET_NETWORK_STRUCT_BEGIN
+struct GNUNET_TRANSPORT_TESTING_TestMessage
+{
+  /**
+   * Type is (usually) #GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Monotonically increasing counter throughout the test.
+   */
+  uint32_t num GNUNET_PACKED;
+};
+
+struct GNUNET_TRANSPORT_TESTING_PerformanceTestMessage
+{
+  /**
+   * Type is (usually) #GNUNET_TRANSPORT_TESTING_SIMPLE_PERFORMANCE_MTYPE.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Time this message was send via transport api.
+   */
+  struct GNUNET_TIME_AbsoluteNBO time_send;
+
+  /**
+   * Monotonically increasing counter throughout the test.
+   */
+  uint32_t num GNUNET_PACKED;
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+
+/**
+ * Function called by the transport for each received message.
+ *
+ * @param cls closure
+ * @param receiver receiver of the message
+ * @param sender sender of the message
+ * @param message the message
+ */
+typedef void (*GNUNET_TRANSPORT_TESTING_ReceiveCallback) (
+  void *cls,
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *receiver,
+  const struct GNUNET_PeerIdentity *sender,
+  const struct GNUNET_TRANSPORT_TESTING_TestMessage *message);
+
+
+/**
+ * Function called to notify transport users that another
+ * peer connected to us.
+ *
+ * @param cls closure
+ * @param me peer experiencing the event
+ * @param other peer that connected to @a me
+ */
+typedef void (*GNUNET_TRANSPORT_TESTING_NotifyConnect) (
+  void *cls,
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *me,
+  const struct GNUNET_PeerIdentity *other);
+
+
+/**
+ * Function called to notify transport users that another
+ * peer disconnected from us.
+ *
+ * @param cls closure
+ * @param me peer experiencing the event
+ * @param other peer that disconnected from @a me
+ */
+typedef void (*GNUNET_TRANSPORT_TESTING_NotifyDisconnect) (
+  void *cls,
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *me,
+  const struct GNUNET_PeerIdentity *other);
+
+
+/**
+ * Closure that must be passed to
+ * #GNUNET_TRANSPORT_TESTING_connect_check.
+ */
+struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext
+{
+  /**
+   * How should we continue after the connect?
+   */
+  GNUNET_SCHEDULER_TaskCallback connect_continuation;
+
+  /**
+   * Closure for @e connect_continuation.
+   */
+  void *connect_continuation_cls;
+
+  /**
+   * Which configuration file should we pass to the
+   * #GNUNET_PROGRAM_run() of the testcase?
+   */
+  const char *config_file;
+
+  /**
+   * Receiver argument to give for peers we start.
+   */
+  GNUNET_TRANSPORT_TESTING_ReceiveCallback rec;
+
+  /**
+   * Notify connect argument to give for peers we start.
+   */
+  GNUNET_TRANSPORT_TESTING_NotifyConnect nc;
+
+  /**
+   * Notify disconnect argument to give for peers we start.
+   */
+  GNUNET_TRANSPORT_TESTING_NotifyDisconnect nd;
+
+  /**
+   * Closure for @e rec, @e nc and @e nd.
+   */
+  void *cls;
+
+  /**
+   * Custom task to run on shutdown.
+   */
+  GNUNET_SCHEDULER_TaskCallback shutdown_task;
+
+  /**
+   * Closure for @e shutdown_task.
+   */
+  void *shutdown_task_cls;
+
+  /**
+   * Custom task to run after peers were started but before we try to
+   * connect them.  If this function is set, we wait ONE second after
+   * running this function until we continue with connecting the
+   * peers.
+   */
+  GNUNET_SCHEDULER_TaskCallback pre_connect_task;
+
+  /**
+   * Closure for @e shutdown_task.
+   */
+  void *pre_connect_task_cls;
+
+  /**
+   * When should the testcase time out?
+   */
+  struct GNUNET_TIME_Relative timeout;
+
+  /**
+   * Should we try to create connections in both directions?
+   */
+  int bi_directional;
+
+  /* ******* fields set by #GNUNET_TRANSPORT_TESTING_connect_check **** */
+
+  /**
+   * Number of peers involved in the test.
+   */
+  unsigned int num_peers;
+
+  /**
+   * Configuration files we have, array with @e num_peers entries.
+   */
+  char **cfg_files;
+
+  /**
+   * Array with @e num_peers entries.
+   */
+  struct GNUNET_TRANSPORT_TESTING_PeerContext **p;
+
+  /**
+   * Name of the plugin.
+   */
+  const char *test_plugin;
+
+  /**
+   * Name of the testcase.
+   */
+  const char *test_name;
+
+  /**
+   * Configuration object for the testcase.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Main testing handle.
+   */
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth;
+
+  /**
+   * Result from the main function, set to #GNUNET_OK on success.
+   * Clients should set to #GNUNET_SYSERR to indicate test failure.
+   */
+  int global_ret;
+
+  /**
+   * Generator for the `num` field in test messages.  Incremented each
+   * time #GNUNET_TRANSPORT_TESTING_simple_send or
+   * #GNUNET_TRANSPORT_TESTING_large_send are used to transmit a
+   * message.
+   */
+  uint32_t send_num_gen;
+
+  /* ******* internal state, clients should not mess with this **** */
+
+  /**
+   * Task run on timeout.
+   */
+  struct GNUNET_SCHEDULER_Task *timeout_task;
+
+  /**
+   * Task run to connect peers.
+   */
+  struct GNUNET_SCHEDULER_Task *connect_task;
+
+  /**
+   * Number of peers that have been started.
+   */
+  unsigned int started;
+
+  /**
+   * DLL of active connect requests.
+   */
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequestList *crl_head;
+
+  /**
+   * DLL of active connect requests.
+   */
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequestList *crl_tail;
+
+  /**
+   * Array with @e num_peers entries.
+   */
+  struct GNUNET_TRANSPORT_TESTING_InternalPeerContext *ip;
+};
+
+
+/**
+ * Find peer by peer ID.
+ *
+ * @param ccc context to search
+ * @param peer peer to look for
+ * @return NULL if @a peer was not found
+ */
+struct GNUNET_TRANSPORT_TESTING_PeerContext *
+GNUNET_TRANSPORT_TESTING_find_peer (
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc,
+  const struct GNUNET_PeerIdentity *peer);
+
+
+/**
+ * Common implementation of the #GNUNET_TRANSPORT_TESTING_CheckCallback.
+ * Starts and connects the two peers, then invokes the
+ * `connect_continuation` from @a cls.  Sets up a timeout to
+ * abort the test, and a shutdown handler to clean up properly
+ * on exit.
+ *
+ * @param cls closure of type `struct
+ * GNUNET_TRANSPORT_TESTING_ConnectCheckContext`
+ * @param tth_ initialized testing handle
+ * @param test_plugin_ name of the plugin
+ * @param test_name_ name of the test
+ * @param num_peers number of entries in the @a cfg_file array
+ * @param cfg_files array of names of configuration files for the peers
+ * @return #GNUNET_SYSERR on error
+ */
+int
+GNUNET_TRANSPORT_TESTING_connect_check (
+  void *cls,
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth_,
+  const char *test_plugin_,
+  const char *test_name_,
+  unsigned int num_peers,
+  char *cfg_files[]);
+
+
+/**
+ * Main function of a testcase.  Called with the initial setup data
+ * for the test as derived from the source name and the binary name.
+ *
+ * @param cls closure
+ * @param tth_ initialized testing handle
+ * @param test_plugin_ name of the plugin
+ * @param test_name_ name of the test
+ * @param num_peers number of entries in the @a cfg_file array
+ * @param cfg_files array of names of configuration files for the peers
+ * @return #GNUNET_SYSERR on error
+ */
+typedef int (*GNUNET_TRANSPORT_TESTING_CheckCallback) (
+  void *cls,
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth_,
+  const char *test_plugin_,
+  const char *test_name_,
+  unsigned int num_peers,
+  char *cfg_files[]);
+
+
+/**
+ * Setup testcase.  Calls @a check with the data the test needs.
+ *
+ * @param argv0 binary name (argv[0])
+ * @param filename source file name (__FILE__)
+ * @param num_peers number of peers to start
+ * @param check main function to run
+ * @param check_cls closure for @a check
+ * @return #GNUNET_OK on success
+ */
+int
+GNUNET_TRANSPORT_TESTING_main_ (const char *argv0,
+                                const char *filename,
+                                unsigned int num_peers,
+                                GNUNET_TRANSPORT_TESTING_CheckCallback check,
+                                void *check_cls);
+
+
+/**
+ * Setup testcase.  Calls @a check with the data the test needs.
+ *
+ * @param num_peers number of peers to start
+ * @param check main function to run
+ * @param check_cls closure for @a check
+ * @return #GNUNET_OK on success
+ */
+#define GNUNET_TRANSPORT_TESTING_main(num_peers, check, check_cls) \
+  GNUNET_TRANSPORT_TESTING_main_ (argv[0],                         \
+                                  __FILE__,                        \
+                                  num_peers,                       \
+                                  check,                           \
+                                  check_cls)
+
+/* ***************** Convenience functions for sending ********* */
+
+/**
+ * Send a test message of type @a mtype and size @a msize from
+ * peer @a sender to peer @a receiver.  The peers should be
+ * connected when this function is called.
+ *
+ * @param sender the sending peer
+ * @param receiver the receiving peer
+ * @param mtype message type to use
+ * @param msize size of the message, at least `sizeof (struct
+ * GNUNET_TRANSPORT_TESTING_TestMessage)`
+ * @param num unique message number
+ * @param cont continuation to call after transmission
+ * @param cont_cls closure for @a cont
+ * @return #GNUNET_OK if message was queued,
+ *         #GNUNET_NO if peers are not connected
+ *         #GNUNET_SYSERR if @a msize is illegal
+ */
+int
+GNUNET_TRANSPORT_TESTING_send (
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *sender,
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *receiver,
+  uint16_t mtype,
+  uint16_t msize,
+  uint32_t num,
+  GNUNET_SCHEDULER_TaskCallback cont,
+  void *cont_cls);
+
+
+/**
+ * Message type used by #GNUNET_TRANSPORT_TESTING_simple_send().
+ */
+#define GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE 12345
+
+/**
+ * Alternative message type for tests.
+ */
+#define GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE2 12346
+
+/**
+ * Message type used by #().
+ */
+#define GNUNET_TRANSPORT_TESTING_SIMPLE_PERFORMANCE_MTYPE 12347
+
+/**
+ * Type of the closure argument to pass to
+ * #GNUNET_TRANSPORT_TESTING_simple_send() and
+ * #GNUNET_TRANSPORT_TESTING_large_send().
+ */
+struct GNUNET_TRANSPORT_TESTING_SendClosure
+{
+  /**
+   * Context for the transmission.
+   */
+  struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc;
+
+  /**
+   * Function that returns the desired message size. Overrides
+   * the message size, can be NULL in which case the message
+   * size is the default.
+   */
+  size_t (*get_size_cb) (unsigned int n);
+
+  /**
+   * Number of messages to be transmitted in a loop.
+   * Use zero for "forever" (until external shutdown).
+   */
+  unsigned int num_messages;
+
+  /**
+   * Function to call after all transmissions, can be NULL.
+   */
+  GNUNET_SCHEDULER_TaskCallback cont;
+
+  /**
+   * Closure for @e cont.
+   */
+  void *cont_cls;
+};
+
+
+/**
+ * Task that sends a minimalistic test message from the
+ * first peer to the second peer.
+ *
+ * @param cls the `struct GNUNET_TRANSPORT_TESTING_SendClosure`
+ *        which should contain at least two peers, the first two
+ *        of which should be currently connected
+ */
+void
+GNUNET_TRANSPORT_TESTING_simple_send (void *cls);
+
+/**
+ * Size of a message sent with
+ * #GNUNET_TRANSPORT_TESTING_large_send().  Big enough
+ * to usually force defragmentation.
+ */
+#define GNUNET_TRANSPORT_TESTING_LARGE_MESSAGE_SIZE 2600
+
+/**
+ * Task that sends a large test message from the
+ * first peer to the second peer.
+ *
+ * @param cls the `struct GNUNET_TRANSPORT_TESTING_SendClosure`
+ *        which should contain at least two peers, the first two
+ *        of which should be currently connected
+ */
+void
+GNUNET_TRANSPORT_TESTING_large_send (void *cls);
+
+
+/* ********************** log-only convenience functions ************* */
+
+
+/**
+ * Log a connect event.
+ *
+ * @param cls NULL
+ * @param me peer that had the event
+ * @param other peer that connected.
+ */
+void
+GNUNET_TRANSPORT_TESTING_log_connect (
+  void *cls,
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *me,
+  const struct GNUNET_PeerIdentity *other);
+
+
+/**
+ * Log a disconnect event.
+ *
+ * @param cls NULL
+ * @param me peer that had the event
+ * @param other peer that disconnected.
+ */
+void
+GNUNET_TRANSPORT_TESTING_log_disconnect (
+  void *cls,
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *me,
+  const struct GNUNET_PeerIdentity *other);
+
+
+/* ********************** low-level filename functions *************** */
+
+
+/**
+ * Extracts the test filename from an absolute file name and removes
+ * the extension.
+ *
+ * @param file absolute file name
+ * @return resulting test name
+ */
+char *
+GNUNET_TRANSPORT_TESTING_get_test_name (const char *file);
+
+
+/**
+ * This function takes the filename (e.g. argv[0), removes a "lt-"-prefix and
+ * if existing ".exe"-prefix and adds the peer-number
+ *
+ * @param file filename of the test, e.g. argv[0]
+ * @param count peer number
+ * @return configuration name to use
+ */
+char *
+GNUNET_TRANSPORT_TESTING_get_config_name (const char *file, int count);
+
+
+/**
+ * Extracts the plugin anme from an absolute file name and the test name
+ * @param file absolute file name
+ * @param test test name
+ * @return the plugin name
+ */
+char *
+GNUNET_TRANSPORT_TESTING_get_test_plugin_name (const char *executable,
+                                               const char *testname);
+
+
+/**
+ * Extracts the filename from an absolute file name and removes the
+ * extension
+ *
+ * @param file absolute file name
+ * @return the source name
+ */
+char *
+GNUNET_TRANSPORT_TESTING_get_test_source_name (const char *file);
+
+#endif
+/* end of transport_testing.h */
diff --git a/src/service/transport/transport.conf.in b/src/service/transport/transport.conf.in
new file mode 100644
index 000000000..6fb8e9ad7
--- /dev/null
+++ b/src/service/transport/transport.conf.in
@@ -0,0 +1,32 @@
+[transport]
+START_ON_DEMAND = @START_ON_DEMAND@
+@JAVAPORT@PORT = 2091
+HOSTNAME = localhost
+BINARY = gnunet-service-transport
+# PREFIX = valgrind
+
+ACCEPT_FROM = 127.0.0.1;
+ACCEPT_FROM6 = ::1;
+UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-transport.sock
+# USERNAME =
+# DISABLEV6 =
+# REJECT_FROM =
+# REJECT_FROM6 =
+# BINDTO =
+
+[communicator-tcp]
+#PREFIX = valgrind --leak-check=full --track-origins=yes
+BINDTO = 2086
+DISABLE_V6 = NO
+BINARY = gnunet-communicator-tcp
+IMMEDIATE_START = YES
+
+[communicator-udp]
+#PREFIX = valgrind --leak-check=full --track-origins=yes --trace-children=yes --log-file=$GNUNET_TEST_HOME/vg_cupeer1-%p
+BINARY = gnunet-communicator-udp
+BINDTO = 2086
+DISABLE_V6 = NO
+IMMEDIATE_START = YES
+
+[communicator-quic]
+BINDTO = 127.0.0.1
diff --git a/src/service/transport/transport.h b/src/service/transport/transport.h
new file mode 100644
index 000000000..66f17ee5b
--- /dev/null
+++ b/src/service/transport/transport.h
@@ -0,0 +1,828 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009-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 transport/transport.h
+ * @brief common internal definitions for transport service
+ * @author Christian Grothoff
+ */
+#ifndef TRANSPORT_H
+#define TRANSPORT_H
+
+#include "gnunet_util_lib.h"
+#include "gnunet_time_lib.h"
+#include "gnunet_constants.h"
+
+#define DEBUG_TRANSPORT GNUNET_EXTRA_LOGGING
+
+
+/**
+ * Similar to GNUNET_TRANSPORT_NotifyDisconnect but in and out quotas are
+ * included here. These values are not required outside transport_api
+ *
+ * @param cls closure
+ * @param peer the peer that connected
+ * @param bandwidth_in inbound bandwidth in NBO
+ * @param bandwidth_out outbound bandwidth in NBO
+ *
+ */
+typedef void (*NotifyConnect) (
+  void *cls,
+  const struct GNUNET_PeerIdentity *peer,
+  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
+  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out);
+
+
+GNUNET_NETWORK_STRUCT_BEGIN
+
+
+/**
+ * Message from the transport service to the library
+ * asking to check if both processes agree about this
+ * peers identity.
+ */
+struct StartMessage
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_START
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * 0: no options
+   * 1: The @e self field should be checked
+   * 2: this client is interested in payload traffic
+   */
+  uint32_t options;
+
+  /**
+   * Identity we think we have.  If it does not match, the
+   * receiver should print out an error message and disconnect.
+   */
+  struct GNUNET_PeerIdentity self;
+};
+
+
+/**
+ * Message from the transport service to the library
+ * informing about neighbors.
+ */
+struct ConnectInfoMessage
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT
+   */
+  struct GNUNET_MessageHeader header;
+
+#if (defined(GNUNET_TRANSPORT_COMMUNICATION_VERSION) || \
+  defined(GNUNET_TRANSPORT_CORE_VERSION))
+
+  /**
+   * Always zero, for alignment.
+   */
+  uint32_t reserved GNUNET_PACKED;
+#else
+  /**
+   * Current outbound quota for this peer
+   */
+  struct GNUNET_BANDWIDTH_Value32NBO quota_out;
+#endif
+
+  /**
+   * Identity of the new neighbour.
+   */
+  struct GNUNET_PeerIdentity id;
+};
+
+
+/**
+ * Message from the transport service to the library
+ * informing about disconnects.
+ */
+struct DisconnectInfoMessage
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Reserved, always zero.
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * Who got disconnected?
+   */
+  struct GNUNET_PeerIdentity peer;
+};
+
+
+/**
+ * Message used to notify the transport API about a message
+ * received from the network.  The actual message follows.
+ */
+struct InboundMessage
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_RECV
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Which peer sent the message?
+   */
+  struct GNUNET_PeerIdentity peer;
+};
+
+
+/**
+ * Message used to notify the transport API that it can
+ * send another message to the transport service.
+ */
+struct SendOkMessage
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK
+   */
+  struct GNUNET_MessageHeader header;
+
+#if (defined(GNUNET_TRANSPORT_COMMUNICATION_VERSION) || \
+  defined(GNUNET_TRANSPORT_CORE_VERSION))
+
+  uint32_t reserved GNUNET_PACKED;
+#else
+  /**
+   * #GNUNET_OK if the transmission succeeded,
+   * #GNUNET_SYSERR if it failed (i.e. network disconnect);
+   * in either case, it is now OK for this client to
+   * send us another message for the given peer.
+   */
+  uint16_t success GNUNET_PACKED;
+
+  /**
+   * Size of message sent
+   */
+  uint16_t bytes_msg GNUNET_PACKED;
+
+  /**
+   * Size of message sent over wire.
+   * Includes plugin and protocol specific overheads.
+   */
+  uint32_t bytes_physical GNUNET_PACKED;
+#endif
+
+  /**
+   * Which peer can send more now?
+   */
+  struct GNUNET_PeerIdentity peer;
+};
+
+
+/**
+ * Message used to notify the transport API that it can
+ * send another message to the transport service.
+ * (Used to implement flow control.)
+ */
+struct RecvOkMessage
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_RECV_OK
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Number of messages by which to increase the window, greater or
+   * equal to one.
+   */
+  uint32_t increase_window_delta GNUNET_PACKED;
+
+  /**
+   * Which peer can CORE handle more from now?
+   */
+  struct GNUNET_PeerIdentity peer;
+};
+
+
+/**
+ * Message used to notify the transport service about a message
+ * to be transmitted to another peer.  The actual message follows.
+ */
+struct OutboundMessage
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SEND
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * An `enum GNUNET_MQ_PriorityPreferences` in NBO.
+   */
+  uint32_t priority GNUNET_PACKED;
+
+#if ! (defined(GNUNET_TRANSPORT_COMMUNICATION_VERSION) || \
+  defined(GNUNET_TRANSPORT_CORE_VERSION))
+
+  /**
+   * Allowed delay.
+   */
+  struct GNUNET_TIME_RelativeNBO timeout;
+#endif
+
+  /**
+   * Which peer should receive the message?
+   */
+  struct GNUNET_PeerIdentity peer;
+};
+
+
+/* *********************** TNG messages ***************** */
+
+/**
+ * Communicator goes online.  Note which addresses it can
+ * work with.
+ */
+struct GNUNET_TRANSPORT_CommunicatorAvailableMessage
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_NEW_COMMUNICATOR.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * NBO encoding of `enum GNUNET_TRANSPORT_CommunicatorCharacteristics`
+   */
+  uint32_t cc;
+
+  /* Followed by the address prefix of the communicator */
+};
+
+
+/**
+ * Add address to the list.
+ */
+struct GNUNET_TRANSPORT_AddAddressMessage
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_ADD_ADDRESS.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Address identifier (used during deletion).
+   */
+  uint32_t aid GNUNET_PACKED;
+
+  /**
+   * When does the address expire?
+   */
+  struct GNUNET_TIME_RelativeNBO expiration;
+
+  /**
+   * An `enum GNUNET_NetworkType` in NBO.
+   */
+  uint32_t nt;
+
+  /* followed by UTF-8 encoded, 0-terminated human-readable address */
+};
+
+
+/**
+ * Remove address from the list.
+ */
+struct GNUNET_TRANSPORT_DelAddressMessage
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_DEL_ADDRESS.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Address identifier.
+   */
+  uint32_t aid GNUNET_PACKED;
+};
+
+
+/**
+ * Inform transport about an incoming message.
+ */
+struct GNUNET_TRANSPORT_IncomingMessage
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Do we use flow control or not?
+   */
+  uint32_t fc_on GNUNET_PACKED;
+
+  /**
+   * 64-bit number to identify the matching ACK.
+   */
+  uint64_t fc_id GNUNET_PACKED;
+
+  /**
+   * How long does the communicator believe the address on which
+   * the message was received to remain valid?
+   */
+  struct GNUNET_TIME_RelativeNBO expected_address_validity;
+
+  /**
+   * Sender identifier.
+   */
+  struct GNUNET_PeerIdentity sender;
+
+  /**
+   * Direct neighbour sender identifier.
+   */
+  struct GNUNET_PeerIdentity neighbour_sender;
+
+  /* followed by the message */
+};
+
+
+/**
+ * Transport informs us about being done with an incoming message.
+ * (only sent if fc_on was set).
+ */
+struct GNUNET_TRANSPORT_IncomingMessageAck
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Reserved (0)
+   */
+  uint32_t reserved GNUNET_PACKED;
+
+  /**
+   * Which message is being ACKed?
+   */
+  uint64_t fc_id GNUNET_PACKED;
+
+  /**
+   * Sender identifier of the original message.
+   */
+  struct GNUNET_PeerIdentity sender;
+};
+
+
+/**
+ * Add queue to the transport
+ */
+struct GNUNET_TRANSPORT_AddQueueMessage
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Queue identifier (used to identify the queue).
+   */
+  uint32_t qid GNUNET_PACKED;
+
+  /**
+   * Receiver that can be addressed via the queue.
+   */
+  struct GNUNET_PeerIdentity receiver;
+
+  /**
+   * An `enum GNUNET_NetworkType` in NBO.
+   */
+  uint32_t nt;
+
+  /**
+   * Maximum transmission unit, in NBO.  UINT32_MAX for unlimited.
+   */
+  uint32_t mtu;
+
+  /**
+   * Queue length, in NBO. Defines how many messages may be
+   * send through this queue. UINT64_MAX for unlimited.
+   */
+  uint64_t q_len;
+
+  /**
+   * Priority of the queue in relation to other queues.
+   */
+  uint32_t priority;
+
+  /**
+   * An `enum GNUNET_TRANSPORT_ConnectionStatus` in NBO.
+   */
+  uint32_t cs;
+
+  /* followed by UTF-8 encoded, 0-terminated human-readable address */
+};
+
+
+/**
+ * Update queue
+ */
+struct GNUNET_TRANSPORT_UpdateQueueMessage
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Queue identifier (used to identify the queue).
+   */
+  uint32_t qid GNUNET_PACKED;
+
+  /**
+   * Receiver that can be addressed via the queue.
+   */
+  struct GNUNET_PeerIdentity receiver;
+
+  /**
+   * An `enum GNUNET_NetworkType` in NBO.
+   */
+  uint32_t nt;
+
+  /**
+   * Maximum transmission unit, in NBO.  UINT32_MAX for unlimited.
+   */
+  uint32_t mtu;
+
+  /**
+   * Queue length, in NBO. Defines how many messages may be
+   * send through this queue. UINT64_MAX for unlimited.
+   */
+  uint64_t q_len;
+
+  /**
+   * Priority of the queue in relation to other queues.
+   */
+  uint32_t priority;
+
+  /**
+   * An `enum GNUNET_TRANSPORT_ConnectionStatus` in NBO.
+   */
+  uint32_t cs;
+};
+
+
+/**
+ * Remove queue, it is no longer available.
+ */
+struct GNUNET_TRANSPORT_DelQueueMessage
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_TEARDOWN.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Address identifier.
+   */
+  uint32_t qid GNUNET_PACKED;
+
+  /**
+   * Receiver that can be addressed via the queue.
+   */
+  struct GNUNET_PeerIdentity receiver;
+};
+
+
+/**
+ * Transport tells communicator that it wants a new queue.
+ */
+struct GNUNET_TRANSPORT_CreateQueue
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Unique ID for the request.
+   */
+  uint32_t request_id GNUNET_PACKED;
+
+  /**
+   * Receiver that can be addressed via the queue.
+   */
+  struct GNUNET_PeerIdentity receiver;
+
+  /* followed by UTF-8 encoded, 0-terminated human-readable address */
+};
+
+
+/**
+ * Communicator tells transport how queue creation went down.
+ */
+struct GNUNET_TRANSPORT_CreateQueueResponse
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_OK or
+   * #GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_FAIL.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Unique ID for the request.
+   */
+  uint32_t request_id GNUNET_PACKED;
+};
+
+
+/**
+ * Inform communicator about transport's desire to send a message.
+ */
+struct GNUNET_TRANSPORT_SendMessageTo
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Which queue should we use?
+   */
+  uint32_t qid GNUNET_PACKED;
+
+  /**
+   * Message ID, used for flow control.
+   */
+  uint64_t mid GNUNET_PACKED;
+
+  /**
+   * Receiver identifier.
+   */
+  struct GNUNET_PeerIdentity receiver;
+
+  /* followed by the message */
+};
+
+
+/**
+ * Inform transport that message was sent.
+ */
+struct GNUNET_TRANSPORT_SendMessageToAck
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG_ACK.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Success (#GNUNET_OK), failure (#GNUNET_SYSERR).
+   */
+  uint32_t status GNUNET_PACKED;
+
+  /**
+   * Message ID of the original message.
+   */
+  uint64_t mid GNUNET_PACKED;
+
+  /**
+   * Queue ID for the queue which was used to send the message.
+   */
+  uint32_t qid GNUNET_PACKED;
+
+  /**
+   * Receiver identifier.
+   */
+  struct GNUNET_PeerIdentity receiver;
+};
+
+
+/**
+ * Message from communicator to transport service asking for
+ * transmission of a backchannel message with the given peer @e pid
+ * and communicator.
+ */
+struct GNUNET_TRANSPORT_CommunicatorBackchannel
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Always zero, for alignment.
+   */
+  uint32_t reserved;
+
+  /**
+   * Target peer.
+   */
+  struct GNUNET_PeerIdentity pid;
+
+  /* Followed by a `struct GNUNET_MessageHeader` with the encapsulated
+     message to the communicator */
+
+  /* Followed by the 0-terminated string specifying the desired
+     communicator at the target (@e pid) peer */
+};
+
+
+/**
+ * Message from transport to communicator passing along a backchannel
+ * message from the given peer @e pid.
+ */
+struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming
+{
+  /**
+   * Type will be
+   * #GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL_INCOMING
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Always zero, for alignment.
+   */
+  uint32_t reserved;
+
+  /**
+   * Origin peer.
+   */
+  struct GNUNET_PeerIdentity pid;
+
+  /* Followed by a `struct GNUNET_MessageHeader` with the encapsulated
+     message to the communicator */
+};
+
+
+/**
+ * Request to start monitoring.
+ */
+struct GNUNET_TRANSPORT_MonitorStart
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_START.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * #GNUNET_YES for one-shot montoring, #GNUNET_NO for continuous monitoring.
+   */
+  uint32_t one_shot;
+
+  /**
+   * Target identifier to monitor, all zeros for "all peers".
+   */
+  struct GNUNET_PeerIdentity peer;
+};
+
+
+/**
+ * Monitoring data.
+ */
+struct GNUNET_TRANSPORT_MonitorData
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Network type (an `enum GNUNET_NetworkType` in NBO).
+   */
+  uint32_t nt GNUNET_PACKED;
+
+  /**
+   * Target identifier.
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /**
+   * @deprecated To be discussed if we keep these...
+   */
+  struct GNUNET_TIME_AbsoluteNBO last_validation;
+  struct GNUNET_TIME_AbsoluteNBO valid_until;
+  struct GNUNET_TIME_AbsoluteNBO next_validation;
+
+  /**
+   * Current round-trip time estimate.
+   */
+  struct GNUNET_TIME_RelativeNBO rtt;
+
+  /**
+   * Connection status (in NBO).
+   */
+  uint32_t cs GNUNET_PACKED;
+
+  /**
+   * Messages pending (in NBO).
+   */
+  uint32_t num_msg_pending GNUNET_PACKED;
+
+  /**
+   * Bytes pending (in NBO).
+   */
+  uint32_t num_bytes_pending GNUNET_PACKED;
+
+  /* Followed by 0-terminated address of the peer */
+};
+
+
+/**
+ * Request to verify address.
+ */
+struct GNUNET_TRANSPORT_AddressToVerify
+{
+  /**
+   * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_CONSIDER_VERIFY.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Reserved. 0.
+   */
+  uint32_t reserved;
+
+  /**
+   * Peer the address is from.
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /* followed by variable-size raw address */
+};
+
+
+/**
+ * Application client to TRANSPORT service: we would like to have
+ * address suggestions for this peer.
+ */
+struct ExpressPreferenceMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST or
+   * #GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST_CANCEL to stop
+   * suggestions.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * What type of performance preference does the client have?
+   * A `enum GNUNET_MQ_PreferenceKind` in NBO.
+   */
+  uint32_t pk GNUNET_PACKED;
+
+  /**
+   * Peer to get address suggestions for.
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /**
+   * How much bandwidth in bytes/second does the application expect?
+   */
+  struct GNUNET_BANDWIDTH_Value32NBO bw;
+};
+
+
+/**
+ * We got an address of another peer, TRANSPORT service
+ * should validate it.  There is no response.
+ */
+struct RequestHelloValidationMessage
+{
+  /**
+   * Type is #GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_HELLO_VALIDATION.
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * What type of network does the other peer claim this is?
+   * A `enum GNUNET_NetworkType` in NBO.
+   */
+  uint32_t nt GNUNET_PACKED;
+
+  /**
+   * Peer to the address is presumably for.
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /* followed by 0-terminated address to validate */
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+/* end of transport.h */
+#endif
diff --git a/src/service/transport/transport_api2_application.c b/src/service/transport/transport_api2_application.c
new file mode 100644
index 000000000..00f5f62eb
--- /dev/null
+++ b/src/service/transport/transport_api2_application.c
@@ -0,0 +1,397 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2010--2019 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 transport/transport_api2_application.c
+ * @brief enable clients to ask TRANSPORT about establishing connections to peers
+ * @author Christian Grothoff
+ * @author Matthias Wachs
+ */
+#include "platform.h"
+#include "gnunet_transport_application_service.h"
+#include "gnunet_transport_core_service.h"
+#include "transport.h"
+
+
+#define LOG(kind, ...) \
+  GNUNET_log_from (kind, "transport-application-api", __VA_ARGS__)
+
+
+/**
+ * Handle for TRANSPORT address suggestion requests.
+ */
+struct GNUNET_TRANSPORT_ApplicationSuggestHandle
+{
+  /**
+   * ID of the peer for which address suggestion was requested.
+   */
+  struct GNUNET_PeerIdentity id;
+
+  /**
+   * Connecitivity handle this suggestion handle belongs to.
+   */
+  struct GNUNET_TRANSPORT_ApplicationHandle *ch;
+
+  /**
+   * What preference is being expressed?
+   */
+  enum GNUNET_MQ_PriorityPreferences pk;
+
+  /**
+   * How much bandwidth does the client expect?
+   */
+  struct GNUNET_BANDWIDTH_Value32NBO bw;
+};
+
+
+/**
+ * Handle to the TRANSPORT subsystem for application management.
+ */
+struct GNUNET_TRANSPORT_ApplicationHandle
+{
+  /**
+   * Our configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Map with the identities of all the peers for which we would
+   * like to have address suggestions.  The key is the PID, the
+   * value is currently the `struct GNUNET_TRANSPORT_ApplicationSuggestHandle`
+   */
+  struct GNUNET_CONTAINER_MultiPeerMap *sug_requests;
+
+  /**
+   * Message queue for sending requests to the TRANSPORT service.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Task to trigger reconnect.
+   */
+  struct GNUNET_SCHEDULER_Task *task;
+
+  /**
+   * Reconnect backoff delay.
+   */
+  struct GNUNET_TIME_Relative backoff;
+};
+
+
+/**
+ * Re-establish the connection to the TRANSPORT service.
+ *
+ * @param ch handle to use to re-connect.
+ */
+static void
+reconnect (struct GNUNET_TRANSPORT_ApplicationHandle *ch);
+
+
+/**
+ * Re-establish the connection to the TRANSPORT service.
+ *
+ * @param cls handle to use to re-connect.
+ */
+static void
+reconnect_task (void *cls)
+{
+  struct GNUNET_TRANSPORT_ApplicationHandle *ch = cls;
+
+  ch->task = NULL;
+  reconnect (ch);
+}
+
+
+/**
+ * Disconnect from TRANSPORT and then reconnect.
+ *
+ * @param ch our handle
+ */
+static void
+force_reconnect (struct GNUNET_TRANSPORT_ApplicationHandle *ch)
+{
+  if (NULL != ch->mq)
+  {
+    GNUNET_MQ_destroy (ch->mq);
+    ch->mq = NULL;
+  }
+  ch->backoff = GNUNET_TIME_STD_BACKOFF (ch->backoff);
+  ch->task = GNUNET_SCHEDULER_add_delayed (ch->backoff, &reconnect_task, ch);
+}
+
+
+/**
+ * We encountered an error handling the MQ to the
+ * TRANSPORT service.  Reconnect.
+ *
+ * @param cls the `struct GNUNET_TRANSPORT_ApplicationHandle`
+ * @param error details about the error
+ */
+static void
+error_handler (void *cls, enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_TRANSPORT_ApplicationHandle *ch = cls;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "TRANSPORT connection died (code %d), reconnecting\n",
+       (int) error);
+  force_reconnect (ch);
+}
+
+
+/**
+ * Transmit request for an address suggestion.
+ *
+ * @param cls the `struct GNUNET_TRANSPORT_ApplicationHandle`
+ * @param peer peer to ask for an address suggestion for
+ * @param value the `struct GNUNET_TRANSPORT_SuggestHandle`
+ * @return #GNUNET_OK (continue to iterate), #GNUNET_SYSERR on
+ *         failure (message queue no longer exists)
+ */
+static int
+transmit_suggestion (void *cls,
+                     const struct GNUNET_PeerIdentity *peer,
+                     void *value)
+{
+  struct GNUNET_TRANSPORT_ApplicationHandle *ch = cls;
+  struct GNUNET_TRANSPORT_ApplicationSuggestHandle *sh = value;
+  struct GNUNET_MQ_Envelope *ev;
+  struct ExpressPreferenceMessage *m;
+
+  if (NULL == ch->mq)
+    return GNUNET_SYSERR;
+  ev = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST);
+  m->pk = htonl ((uint32_t) sh->pk);
+  m->bw = sh->bw;
+  m->peer = *peer;
+  GNUNET_MQ_send (ch->mq, ev);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Re-establish the connection to the TRANSPORT service.
+ *
+ * @param ch handle to use to re-connect.
+ */
+static void
+reconnect (struct GNUNET_TRANSPORT_ApplicationHandle *ch)
+{
+  static const struct GNUNET_MQ_MessageHandler handlers[] = { { NULL, 0, 0 } };
+
+  GNUNET_assert (NULL == ch->mq);
+  ch->mq =
+    GNUNET_CLIENT_connect (ch->cfg, "transport", handlers, &error_handler, ch);
+  if (NULL == ch->mq)
+  {
+    force_reconnect (ch);
+    return;
+  }
+  GNUNET_CONTAINER_multipeermap_iterate (ch->sug_requests,
+                                         &transmit_suggestion,
+                                         ch);
+}
+
+
+/**
+ * Initialize the TRANSPORT application suggestion client handle.
+ *
+ * @param cfg configuration to use
+ * @return transport application handle, NULL on error
+ */
+struct GNUNET_TRANSPORT_ApplicationHandle *
+GNUNET_TRANSPORT_application_init (
+  const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_TRANSPORT_ApplicationHandle *ch;
+
+  ch = GNUNET_new (struct GNUNET_TRANSPORT_ApplicationHandle);
+  ch->cfg = cfg;
+  ch->sug_requests = GNUNET_CONTAINER_multipeermap_create (32, GNUNET_YES);
+  reconnect (ch);
+  return ch;
+}
+
+
+/**
+ * Function called to free all `struct GNUNET_TRANSPORT_ApplicationSuggestHandle`s
+ * in the map.
+ *
+ * @param cls NULL
+ * @param key the key
+ * @param value the value to free
+ * @return #GNUNET_OK (continue to iterate)
+ */
+static int
+free_sug_handle (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
+{
+  struct GNUNET_TRANSPORT_ApplicationSuggestHandle *cur = value;
+
+  GNUNET_free (cur);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Client is done with TRANSPORT application management, release resources.
+ *
+ * @param ch handle to release
+ */
+void
+GNUNET_TRANSPORT_application_done (
+  struct GNUNET_TRANSPORT_ApplicationHandle *ch)
+{
+  if (NULL != ch->mq)
+  {
+    GNUNET_MQ_destroy (ch->mq);
+    ch->mq = NULL;
+  }
+  if (NULL != ch->task)
+  {
+    GNUNET_SCHEDULER_cancel (ch->task);
+    ch->task = NULL;
+  }
+  GNUNET_CONTAINER_multipeermap_iterate (ch->sug_requests,
+                                         &free_sug_handle,
+                                         NULL);
+  GNUNET_CONTAINER_multipeermap_destroy (ch->sug_requests);
+  GNUNET_free (ch);
+}
+
+
+/**
+ * An application would like TRANSPORT to connect to a peer.
+ *
+ * @param ch handle
+ * @param peer identity of the peer we need an address for
+ * @param pk what kind of application will the application require (can be
+ *         #GNUNET_MQ_PRIO_BACKGROUND, we will still try to connect)
+ * @param bw desired bandwidth, can be zero (we will still try to connect)
+ * @return suggest handle, NULL if a request is already pending
+ */
+struct GNUNET_TRANSPORT_ApplicationSuggestHandle *
+GNUNET_TRANSPORT_application_suggest (
+  struct GNUNET_TRANSPORT_ApplicationHandle *ch,
+  const struct GNUNET_PeerIdentity *peer,
+  enum GNUNET_MQ_PriorityPreferences pk,
+  struct GNUNET_BANDWIDTH_Value32NBO bw)
+{
+  struct GNUNET_TRANSPORT_ApplicationSuggestHandle *s;
+
+  s = GNUNET_new (struct GNUNET_TRANSPORT_ApplicationSuggestHandle);
+  s->ch = ch;
+  s->id = *peer;
+  s->pk = pk;
+  s->bw = bw;
+  (void) GNUNET_CONTAINER_multipeermap_put (
+    ch->sug_requests,
+    &s->id,
+    s,
+    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Requesting TRANSPORT to suggest address for `%s'\n",
+       GNUNET_i2s (peer));
+  if (NULL == ch->mq)
+    return s;
+  GNUNET_assert (GNUNET_OK == transmit_suggestion (ch, &s->id, s));
+  return s;
+}
+
+
+/**
+ * We no longer care about being connected to a peer.
+ *
+ * @param sh handle to stop
+ */
+void
+GNUNET_TRANSPORT_application_suggest_cancel (
+  struct GNUNET_TRANSPORT_ApplicationSuggestHandle *sh)
+{
+  struct GNUNET_TRANSPORT_ApplicationHandle *ch = sh->ch;
+  struct GNUNET_MQ_Envelope *ev;
+  struct ExpressPreferenceMessage *m;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Telling TRANSPORT we no longer care for an address for `%s'\n",
+       GNUNET_i2s (&sh->id));
+  GNUNET_assert (
+    GNUNET_OK ==
+    GNUNET_CONTAINER_multipeermap_remove (ch->sug_requests, &sh->id, sh));
+  if (NULL == ch->mq)
+  {
+    GNUNET_free (sh);
+    return;
+  }
+  ev = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_TRANSPORT_SUGGEST_CANCEL);
+  m->pk = htonl ((uint32_t) sh->pk);
+  m->bw = sh->bw;
+  m->peer = sh->id;
+  GNUNET_MQ_send (ch->mq, ev);
+  GNUNET_free (sh);
+}
+
+
+/**
+ * An application (or a communicator) has received a HELLO (or other address
+ * data of another peer) and wants TRANSPORT to validate that the address is
+ * correct.  The result is NOT returned, in fact TRANSPORT may do nothing
+ * (i.e. if it has too many active validations or recently tried this one
+ * already).  If the @a addr validates, TRANSPORT will persist the address
+ * with PEERSTORE.
+ *
+ * @param ch handle
+ * @param peer identity of the peer we have an address for
+ * @param nt network type of @a addr (as claimed by the other peer);
+ *        used by TRANSPORT to avoid trying @a addr's that really cannot work
+ *        due to network type mismatches
+ * @param addr address to validate
+ */
+void
+GNUNET_TRANSPORT_application_validate (
+  struct GNUNET_TRANSPORT_ApplicationHandle *ch,
+  const struct GNUNET_PeerIdentity *peer,
+  enum GNUNET_NetworkType nt,
+  const char *addr)
+{
+  struct GNUNET_MQ_Envelope *ev;
+  struct RequestHelloValidationMessage *m;
+  size_t alen;
+
+  if (NULL == ch->mq)
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_WARNING,
+      "Address validation for %s:%s skipped as transport is not connected\n",
+      GNUNET_i2s (peer),
+      addr);
+    return;
+  }
+  alen = strlen (addr) + 1;
+  ev =
+    GNUNET_MQ_msg_extra (m,
+                         alen,
+                         GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_HELLO_VALIDATION);
+  m->peer = *peer;
+  m->nt = htonl ((uint32_t) nt);
+  memcpy (&m[1], addr, alen);
+  GNUNET_MQ_send (ch->mq, ev);
+}
+
+
+/* end of transport_api2_application.c */
diff --git a/src/service/transport/transport_api2_communication.c b/src/service/transport/transport_api2_communication.c
new file mode 100644
index 000000000..e0fdad214
--- /dev/null
+++ b/src/service/transport/transport_api2_communication.c
@@ -0,0 +1,1126 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 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 transport/transport_api2_communication.c
+ * @brief implementation of the gnunet_transport_communication_service.h API
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_transport_communication_service.h"
+#include "transport.h"
+
+
+/**
+ * How many messages do we keep at most in the queue to the
+ * transport service before we start to drop (default,
+ * can be changed via the configuration file).
+ */
+#define DEFAULT_MAX_QUEUE_LENGTH 16
+
+
+/**
+ * Information we track per packet to enable flow control.
+ */
+struct FlowControl
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct FlowControl *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct FlowControl *prev;
+
+  /**
+   * Function to call once the message was processed.
+   */
+  GNUNET_TRANSPORT_MessageCompletedCallback cb;
+
+  /**
+   * Closure for @e cb
+   */
+  void *cb_cls;
+
+  /**
+   * Which peer is this about?
+   */
+  struct GNUNET_PeerIdentity sender;
+
+  /**
+   * More-or-less unique ID for the message.
+   */
+  uint64_t id;
+};
+
+
+/**
+ * Information we track per message to tell the transport about
+ * success or failures.
+ */
+struct AckPending
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct AckPending *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct AckPending *prev;
+
+  /**
+   * Communicator this entry belongs to.
+   */
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch;
+
+  /**
+   * Which peer is this about?
+   */
+  struct GNUNET_PeerIdentity receiver;
+
+  /**
+   * More-or-less unique ID for the message.
+   */
+  uint64_t mid;
+
+  /**
+   * Queue ID of the queue which will be used for the message.
+   */
+  uint32_t qid;
+};
+
+
+/**
+ * Opaque handle to the transport service for communicators.
+ */
+struct GNUNET_TRANSPORT_CommunicatorHandle
+{
+  /**
+   * Head of DLL of addresses this communicator offers to the transport service.
+   */
+  struct GNUNET_TRANSPORT_AddressIdentifier *ai_head;
+
+  /**
+   * Tail of DLL of addresses this communicator offers to the transport service.
+   */
+  struct GNUNET_TRANSPORT_AddressIdentifier *ai_tail;
+
+  /**
+   * DLL of messages awaiting flow control confirmation (ack).
+   */
+  struct FlowControl *fc_head;
+
+  /**
+   * DLL of messages awaiting flow control confirmation (ack).
+   */
+  struct FlowControl *fc_tail;
+
+  /**
+   * DLL of messages awaiting transmission confirmation (ack).
+   */
+  struct AckPending *ap_head;
+
+  /**
+   * DLL of messages awaiting transmission confirmation (ack).
+   */
+  struct AckPending *ap_tail;
+
+  /**
+   * DLL of queues we offer.
+   */
+  struct GNUNET_TRANSPORT_QueueHandle *queue_head;
+
+  /**
+   * DLL of queues we offer.
+   */
+  struct GNUNET_TRANSPORT_QueueHandle *queue_tail;
+
+  /**
+   * Our configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Config section to use.
+   */
+  const char *config_section;
+
+  /**
+   * Address prefix to use.
+   */
+  const char *addr_prefix;
+
+  /**
+   * Function to call when the transport service wants us to initiate
+   * a communication channel with another peer.
+   */
+  GNUNET_TRANSPORT_CommunicatorMqInit mq_init;
+
+  /**
+   * Closure for @e mq_init.
+   */
+  void *mq_init_cls;
+
+  /**
+   * Function to call when the transport service receives messages
+   * for a communicator (i.e. for NAT traversal or for non-bidirectional
+   * communicators).
+   */
+  GNUNET_TRANSPORT_CommunicatorNotify notify_cb;
+
+  /**
+   * Closure for @e notify_Cb.
+   */
+  void *notify_cb_cls;
+
+  /**
+   * Queue to talk to the transport service.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Maximum permissible queue length.
+   */
+  unsigned long long max_queue_length;
+
+  /**
+   * Flow-control identifier generator.
+   */
+  uint64_t fc_gen;
+
+  /**
+   * Internal UUID for the address used in communication with the
+   * transport service.
+   */
+  uint32_t aid_gen;
+
+  /**
+   * Queue identifier generator.
+   */
+  uint32_t queue_gen;
+
+  /**
+   * Characteristics of the communicator.
+   */
+  enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc;
+};
+
+
+/**
+ * Handle returned to identify the internal data structure the transport
+ * API has created to manage a message queue to a particular peer.
+ */
+struct GNUNET_TRANSPORT_QueueHandle
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct GNUNET_TRANSPORT_QueueHandle *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct GNUNET_TRANSPORT_QueueHandle *prev;
+
+  /**
+   * Handle this queue belongs to.
+   */
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch;
+
+  /**
+   * Address used by the communication queue.
+   */
+  char *address;
+
+  /**
+   * The queue itself.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Which peer we can communciate with.
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /**
+   * Network type of the communication queue.
+   */
+  enum GNUNET_NetworkType nt;
+
+  /**
+   * Communication status of the queue.
+   */
+  enum GNUNET_TRANSPORT_ConnectionStatus cs;
+
+  /**
+   * ID for this queue when talking to the transport service.
+   */
+  uint32_t queue_id;
+
+  /**
+   * Maximum transmission unit for the queue.
+   */
+  uint32_t mtu;
+
+  /**
+   * Queue length.
+   */
+  uint64_t q_len;
+  /**
+   * Queue priority.
+   */
+  uint32_t priority;
+};
+
+
+/**
+ * Internal representation of an address a communicator is
+ * currently providing for the transport service.
+ */
+struct GNUNET_TRANSPORT_AddressIdentifier
+{
+  /**
+   * Kept in a DLL.
+   */
+  struct GNUNET_TRANSPORT_AddressIdentifier *next;
+
+  /**
+   * Kept in a DLL.
+   */
+  struct GNUNET_TRANSPORT_AddressIdentifier *prev;
+
+  /**
+   * Transport handle where the address was added.
+   */
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch;
+
+  /**
+   * The actual address.
+   */
+  char *address;
+
+  /**
+   * When does the address expire? (Expected lifetime of the
+   * address.)
+   */
+  struct GNUNET_TIME_Relative expiration;
+
+  /**
+   * Internal UUID for the address used in communication with the
+   * transport service.
+   */
+  uint32_t aid;
+
+  /**
+   * Network type for the address.
+   */
+  enum GNUNET_NetworkType nt;
+};
+
+
+/**
+ * (re)connect our communicator to the transport service
+ *
+ * @param ch handle to reconnect
+ */
+static void
+reconnect (struct GNUNET_TRANSPORT_CommunicatorHandle *ch);
+
+
+/**
+ * Send message to the transport service about address @a ai
+ * being now available.
+ *
+ * @param ai address to add
+ */
+static void
+send_add_address (struct GNUNET_TRANSPORT_AddressIdentifier *ai)
+{
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_TRANSPORT_AddAddressMessage *aam;
+
+  if (NULL == ai->ch->mq)
+    return;
+  env = GNUNET_MQ_msg_extra (aam,
+                             strlen (ai->address) + 1,
+                             GNUNET_MESSAGE_TYPE_TRANSPORT_ADD_ADDRESS);
+  aam->expiration = GNUNET_TIME_relative_hton (ai->expiration);
+  aam->nt = htonl ((uint32_t) ai->nt);
+  memcpy (&aam[1], ai->address, strlen (ai->address) + 1);
+  GNUNET_MQ_send (ai->ch->mq, env);
+}
+
+
+/**
+ * Send message to the transport service about address @a ai
+ * being no longer available.
+ *
+ * @param ai address to delete
+ */
+static void
+send_del_address (struct GNUNET_TRANSPORT_AddressIdentifier *ai)
+{
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_TRANSPORT_DelAddressMessage *dam;
+
+  if (NULL == ai->ch->mq)
+    return;
+  env = GNUNET_MQ_msg (dam, GNUNET_MESSAGE_TYPE_TRANSPORT_DEL_ADDRESS);
+  dam->aid = htonl (ai->aid);
+  GNUNET_MQ_send (ai->ch->mq, env);
+}
+
+
+/**
+ * Send message to the transport service about queue @a qh
+ * being now available.
+ *
+ * @param qh queue to add
+ */
+static void
+send_add_queue (struct GNUNET_TRANSPORT_QueueHandle *qh)
+{
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_TRANSPORT_AddQueueMessage *aqm;
+
+  if (NULL == qh->ch->mq)
+    return;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending `GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP` message\n");
+  env = GNUNET_MQ_msg_extra (aqm,
+                             strlen (qh->address) + 1,
+                             GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP);
+  aqm->qid = htonl (qh->queue_id);
+  aqm->receiver = qh->peer;
+  aqm->nt = htonl ((uint32_t) qh->nt);
+  aqm->mtu = htonl (qh->mtu);
+  aqm->q_len = GNUNET_htonll (qh->q_len);
+  aqm->priority = htonl (qh->priority);
+  aqm->cs = htonl ((uint32_t) qh->cs);
+  memcpy (&aqm[1], qh->address, strlen (qh->address) + 1);
+  GNUNET_MQ_send (qh->ch->mq, env);
+}
+
+
+/**
+ * Send message to the transport service about queue @a qh
+ * updated.
+ *
+ * @param qh queue to add
+ */
+static void
+send_update_queue (struct GNUNET_TRANSPORT_QueueHandle *qh)
+{
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_TRANSPORT_UpdateQueueMessage *uqm;
+
+  if (NULL == qh->ch->mq)
+    return;
+  env = GNUNET_MQ_msg (uqm, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_UPDATE);
+  uqm->qid = htonl (qh->queue_id);
+  uqm->receiver = qh->peer;
+  uqm->nt = htonl ((uint32_t) qh->nt);
+  uqm->mtu = htonl (qh->mtu);
+  uqm->q_len = GNUNET_htonll (qh->q_len);
+  uqm->priority = htonl (qh->priority);
+  uqm->cs = htonl ((uint32_t) qh->cs);
+  GNUNET_MQ_send (qh->ch->mq, env);
+}
+
+
+/**
+ * Send message to the transport service about queue @a qh
+ * being no longer available.
+ *
+ * @param qh queue to delete
+ */
+static void
+send_del_queue (struct GNUNET_TRANSPORT_QueueHandle *qh)
+{
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_TRANSPORT_DelQueueMessage *dqm;
+
+  if (NULL == qh->ch->mq)
+    return;
+  env = GNUNET_MQ_msg (dqm, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_TEARDOWN);
+  dqm->qid = htonl (qh->queue_id);
+  dqm->receiver = qh->peer;
+  GNUNET_MQ_send (qh->ch->mq, env);
+}
+
+
+/**
+ * Disconnect from the transport service.  Purges
+ * all flow control entries as we will no longer receive
+ * the ACKs.  Purges the ack pending entries as the
+ * transport will no longer expect the confirmations.
+ *
+ * @param ch service to disconnect from
+ */
+static void
+disconnect (struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
+{
+  struct FlowControl *fcn;
+  struct AckPending *apn;
+
+  for (struct FlowControl *fc = ch->fc_head; NULL != fc; fc = fcn)
+  {
+    fcn = fc->next;
+    GNUNET_CONTAINER_DLL_remove (ch->fc_head, ch->fc_tail, fc);
+    fc->cb (fc->cb_cls, GNUNET_SYSERR);
+    GNUNET_free (fc);
+  }
+  for (struct AckPending *ap = ch->ap_head; NULL != ap; ap = apn)
+  {
+    apn = ap->next;
+    GNUNET_CONTAINER_DLL_remove (ch->ap_head, ch->ap_tail, ap);
+    GNUNET_free (ap);
+  }
+  if (NULL == ch->mq)
+    return;
+  GNUNET_MQ_destroy (ch->mq);
+  ch->mq = NULL;
+}
+
+
+/**
+ * Function called on MQ errors.
+ */
+static void
+error_handler (void *cls, enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "MQ failure %d, reconnecting to transport service.\n",
+              error);
+  disconnect (ch);
+  /* TODO: maybe do this with exponential backoff/delay */
+  reconnect (ch);
+}
+
+
+/**
+ * Transport service acknowledged a message we gave it
+ * (with flow control enabled). Tell the communicator.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_CommunicatorHandle *`
+ * @param incoming_ack the ack
+ */
+static void
+handle_incoming_ack (
+  void *cls,
+  const struct GNUNET_TRANSPORT_IncomingMessageAck *incoming_ack)
+{
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch = cls;
+
+  for (struct FlowControl *fc = ch->fc_head; NULL != fc; fc = fc->next)
+  {
+    if ((fc->id == incoming_ack->fc_id) &&
+        (0 == memcmp (&fc->sender,
+                      &incoming_ack->sender,
+                      sizeof(struct GNUNET_PeerIdentity))))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Done with message with flow control id %" PRIu64
+                  " for sender %s from sender %s\n",
+                  incoming_ack->fc_id,
+                  GNUNET_i2s (&fc->sender),
+                  GNUNET_i2s (&incoming_ack->sender));
+      GNUNET_CONTAINER_DLL_remove (ch->fc_head, ch->fc_tail, fc);
+      fc->cb (fc->cb_cls, GNUNET_OK);
+      GNUNET_free (fc);
+      return;
+    }
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Message with flow control id %" PRIu64
+              " from sender %s not found\n",
+              incoming_ack->fc_id,
+              GNUNET_i2s (&incoming_ack->sender));
+  GNUNET_break (0);
+  disconnect (ch);
+  /* TODO: maybe do this with exponential backoff/delay */
+  reconnect (ch);
+}
+
+
+/**
+ * Transport service wants us to create a queue. Check if @a cq
+ * is well-formed.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_CommunicatorHandle *`
+ * @param cq the queue creation request
+ * @return #GNUNET_OK if @a smt is well-formed
+ */
+static int
+check_create_queue (void *cls, const struct GNUNET_TRANSPORT_CreateQueue *cq)
+{
+  (void) cls;
+  GNUNET_MQ_check_zero_termination (cq);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Transport service wants us to create a queue. Tell the communicator.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_CommunicatorHandle *`
+ * @param cq the queue creation request
+ */
+static void
+handle_create_queue (void *cls, const struct GNUNET_TRANSPORT_CreateQueue *cq)
+{
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch = cls;
+  const char *addr = (const char *) &cq[1];
+  struct GNUNET_TRANSPORT_CreateQueueResponse *cqr;
+  struct GNUNET_MQ_Envelope *env;
+  int ret = ch->mq_init (ch->mq_init_cls, &cq->receiver, addr);
+
+  if (GNUNET_NO == ret)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Address `%s' is already (beging) connected to.\n",
+                addr);
+    env = GNUNET_MQ_msg (cqr, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_FAIL);
+  }
+  else if (GNUNET_SYSERR == ret)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Address `%s' invalid for this communicator\n",
+                addr);
+    env = GNUNET_MQ_msg (cqr, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_FAIL);
+  }
+  else
+  {
+    env = GNUNET_MQ_msg (cqr, GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_OK);
+  }
+  cqr->request_id = cq->request_id;
+  GNUNET_MQ_send (ch->mq, env);
+}
+
+
+/**
+ * Transport service wants us to send a message. Check if @a smt
+ * is well-formed.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_CommunicatorHandle *`
+ * @param smt the transmission request
+ * @return #GNUNET_OK if @a smt is well-formed
+ */
+static int
+check_send_msg (void *cls, const struct GNUNET_TRANSPORT_SendMessageTo *smt)
+{
+  (void) cls;
+  GNUNET_MQ_check_boxed_message (smt);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Notify transport service about @a status of a message with
+ * @a mid sent to @a receiver.
+ *
+ * @param ch handle
+ * @param status #GNUNET_OK on success, #GNUNET_SYSERR on failure
+ * @param receiver which peer was the receiver
+ * @param mid message that the ack is about
+ */
+static void
+send_ack (struct GNUNET_TRANSPORT_CommunicatorHandle *ch,
+          int status,
+          const struct GNUNET_PeerIdentity *receiver,
+          uint64_t mid,
+          uint32_t qid)
+{
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_TRANSPORT_SendMessageToAck *ack;
+
+  env = GNUNET_MQ_msg (ack, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG_ACK);
+  ack->status = htonl (status);
+  ack->mid = mid;
+  ack->qid = qid;
+  ack->receiver = *receiver;
+  GNUNET_MQ_send (ch->mq, env);
+}
+
+
+/**
+ * Message queue transmission by communicator was successful,
+ * notify transport service.
+ *
+ * @param cls an `struct AckPending *`
+ */
+static void
+send_ack_cb (void *cls)
+{
+  struct AckPending *ap = cls;
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch = ap->ch;
+
+  if (NULL != ch->ap_head && NULL != ap)
+    GNUNET_CONTAINER_DLL_remove (ch->ap_head, ch->ap_tail, ap);
+  if (NULL != ap)
+  {
+    send_ack (ch, GNUNET_OK, &ap->receiver, ap->mid, ap->qid);
+    GNUNET_free (ap);
+  }
+}
+
+
+/**
+ * Transport service wants us to send a message. Tell the communicator.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_CommunicatorHandle *`
+ * @param smt the transmission request
+ */
+static void
+handle_send_msg (void *cls, const struct GNUNET_TRANSPORT_SendMessageTo *smt)
+{
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch = cls;
+  const struct GNUNET_MessageHeader *mh;
+  struct GNUNET_MQ_Envelope *env;
+  struct AckPending *ap;
+  struct GNUNET_TRANSPORT_QueueHandle *qh;
+
+  for (qh = ch->queue_head; NULL != qh; qh = qh->next)
+    if ((qh->queue_id == ntohl (smt->qid)) &&
+        (0 == memcmp (&qh->peer,
+                      &smt->receiver,
+                      sizeof(struct GNUNET_PeerIdentity))))
+      break;
+  if (NULL == qh)
+  {
+    /* queue is already gone, tell transport this one failed */
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Transmission failed, queue no longer exists.\n");
+    send_ack (ch, GNUNET_NO, &smt->receiver, smt->mid, smt->qid);
+    return;
+  }
+  ap = GNUNET_new (struct AckPending);
+  ap->ch = ch;
+  ap->receiver = smt->receiver;
+  ap->mid = smt->mid;
+  ap->qid = smt->qid;
+  GNUNET_CONTAINER_DLL_insert (ch->ap_head, ch->ap_tail, ap);
+  mh = (const struct GNUNET_MessageHeader *) &smt[1];
+  env = GNUNET_MQ_msg_copy (mh);
+  GNUNET_MQ_notify_sent (env, &send_ack_cb, ap);
+  GNUNET_MQ_send (qh->mq, env);
+}
+
+
+/**
+ * Transport service gives us backchannel message. Check if @a bi
+ * is well-formed.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_CommunicatorHandle *`
+ * @param bi the backchannel message
+ * @return #GNUNET_OK if @a smt is well-formed
+ */
+static int
+check_backchannel_incoming (
+  void *cls,
+  const struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming *bi)
+{
+  (void) cls;
+  GNUNET_MQ_check_boxed_message (bi);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Transport service gives us backchannel message. Handle it.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_CommunicatorHandle *`
+ * @param bi the backchannel message
+ */
+static void
+handle_backchannel_incoming (
+  void *cls,
+  const struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming *bi)
+{
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch = cls;
+  if (NULL != ch->notify_cb)
+    ch->notify_cb (ch->notify_cb_cls,
+                   &bi->pid,
+                   (const struct GNUNET_MessageHeader *) &bi[1]);
+  else
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_INFO,
+      _ ("Dropped backchanel message: handler not provided by communicator\n"));
+}
+
+
+/**
+ * (re)connect our communicator to the transport service
+ *
+ * @param ch handle to reconnect
+ */
+static void
+reconnect (struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
+{
+  struct GNUNET_MQ_MessageHandler handlers[] =
+  { GNUNET_MQ_hd_fixed_size (incoming_ack,
+                             GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK,
+                             struct GNUNET_TRANSPORT_IncomingMessageAck,
+                             ch),
+    GNUNET_MQ_hd_var_size (create_queue,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE,
+                           struct GNUNET_TRANSPORT_CreateQueue,
+                           ch),
+    GNUNET_MQ_hd_var_size (send_msg,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG,
+                           struct GNUNET_TRANSPORT_SendMessageTo,
+                           ch),
+    GNUNET_MQ_hd_var_size (
+      backchannel_incoming,
+      GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL_INCOMING,
+      struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming,
+      ch),
+    GNUNET_MQ_handler_end () };
+  struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam;
+  struct GNUNET_MQ_Envelope *env;
+
+  ch->mq =
+    GNUNET_CLIENT_connect (ch->cfg, "transport", handlers, &error_handler, ch);
+  if (NULL == ch->mq)
+    return;
+  env = GNUNET_MQ_msg_extra (cam,
+                             strlen (ch->addr_prefix) + 1,
+                             GNUNET_MESSAGE_TYPE_TRANSPORT_NEW_COMMUNICATOR);
+  cam->cc = htonl ((uint32_t) ch->cc);
+  memcpy (&cam[1], ch->addr_prefix, strlen (ch->addr_prefix) + 1);
+  GNUNET_MQ_send (ch->mq, env);
+  for (struct GNUNET_TRANSPORT_AddressIdentifier *ai = ch->ai_head; NULL != ai;
+       ai = ai->next)
+    send_add_address (ai);
+  for (struct GNUNET_TRANSPORT_QueueHandle *qh = ch->queue_head; NULL != qh;
+       qh = qh->next)
+    send_add_queue (qh);
+}
+
+
+struct GNUNET_TRANSPORT_CommunicatorHandle *
+GNUNET_TRANSPORT_communicator_connect (
+  const struct GNUNET_CONFIGURATION_Handle *cfg,
+  const char *config_section,
+  const char *addr_prefix,
+  enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc,
+  GNUNET_TRANSPORT_CommunicatorMqInit mq_init,
+  void *mq_init_cls,
+  GNUNET_TRANSPORT_CommunicatorNotify notify_cb,
+  void *notify_cb_cls)
+{
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch;
+
+  ch = GNUNET_new (struct GNUNET_TRANSPORT_CommunicatorHandle);
+  ch->cfg = cfg;
+  ch->config_section = config_section;
+  ch->addr_prefix = addr_prefix;
+  ch->mq_init = mq_init;
+  ch->mq_init_cls = mq_init_cls;
+  ch->notify_cb = notify_cb;
+  ch->notify_cb_cls = notify_cb_cls;
+  ch->cc = cc;
+  reconnect (ch);
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_number (cfg,
+                                             config_section,
+                                             "MAX_QUEUE_LENGTH",
+                                             &ch->max_queue_length))
+    ch->max_queue_length = DEFAULT_MAX_QUEUE_LENGTH;
+  if (NULL == ch->mq)
+  {
+    GNUNET_free (ch);
+    return NULL;
+  }
+  return ch;
+}
+
+
+/**
+ * Disconnect from the transport service.
+ *
+ * @param ch handle returned from connect
+ */
+void
+GNUNET_TRANSPORT_communicator_disconnect (
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
+{
+  disconnect (ch);
+  while (NULL != ch->ai_head)
+  {
+    GNUNET_break (0);  /* communicator forgot to remove address, warn! */
+    GNUNET_TRANSPORT_communicator_address_remove (ch->ai_head);
+  }
+  GNUNET_free (ch);
+}
+
+
+/* ************************* Receiving *************************** */
+
+
+int
+GNUNET_TRANSPORT_communicator_receive (
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch,
+  const struct GNUNET_PeerIdentity *sender,
+  const struct GNUNET_MessageHeader *msg,
+  struct GNUNET_TIME_Relative expected_addr_validity,
+  GNUNET_TRANSPORT_MessageCompletedCallback cb,
+  void *cb_cls)
+{
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_TRANSPORT_IncomingMessage *im;
+  uint16_t msize;
+
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "communicator receive\n");
+
+  if (NULL == ch->mq)
+    return GNUNET_SYSERR;
+  if ((NULL == cb) && (GNUNET_MQ_get_length (ch->mq) >= ch->max_queue_length))
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_WARNING,
+      "Dropping message: transport is too slow, queue length %llu exceeded\n",
+      ch->max_queue_length);
+    return GNUNET_NO;
+  }
+
+  msize = ntohs (msg->size);
+  env =
+    GNUNET_MQ_msg_extra (im, msize, GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG);
+  if (NULL == env)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  im->expected_address_validity =
+    GNUNET_TIME_relative_hton (expected_addr_validity);
+  im->sender = *sender;
+  // FIXME: this is expensive, would be better if we would
+  // re-design the API to allow us to create the envelope first,
+  // and then have the application fill in the body so we do
+  // not have to memcpy()
+  memcpy (&im[1], msg, msize);
+  im->fc_on = htonl (GNUNET_NO);
+  if (NULL != cb)
+  {
+    struct FlowControl *fc;
+
+    im->fc_on = htonl (GNUNET_YES);
+    im->fc_id = ch->fc_gen++;
+    fc = GNUNET_new (struct FlowControl);
+    fc->sender = *sender;
+    fc->id = im->fc_id;
+    fc->cb = cb;
+    fc->cb_cls = cb_cls;
+    GNUNET_CONTAINER_DLL_insert (ch->fc_head, ch->fc_tail, fc);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Created flow control id %" PRIu64 " for sender %s\n",
+                fc->id,
+                GNUNET_i2s (&fc->sender));
+  }
+  GNUNET_MQ_send (ch->mq, env);
+  return GNUNET_OK;
+}
+
+
+/* ************************* Discovery *************************** */
+
+
+struct GNUNET_TRANSPORT_QueueHandle *
+GNUNET_TRANSPORT_communicator_mq_add (
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch,
+  const struct GNUNET_PeerIdentity *peer,
+  const char *address,
+  uint32_t mtu,
+  uint64_t q_len,
+  uint32_t priority,
+  enum GNUNET_NetworkType nt,
+  enum GNUNET_TRANSPORT_ConnectionStatus cs,
+  struct GNUNET_MQ_Handle *mq)
+{
+  struct GNUNET_TRANSPORT_QueueHandle *qh;
+
+  // Do not notify the service if there is no intial capacity.
+  GNUNET_assert (0 < q_len);
+
+  qh = GNUNET_new (struct GNUNET_TRANSPORT_QueueHandle);
+  qh->ch = ch;
+  qh->peer = *peer;
+  qh->address = GNUNET_strdup (address);
+  qh->nt = nt;
+  qh->mtu = mtu;
+  qh->q_len = q_len;
+  qh->priority = priority;
+  qh->cs = cs;
+  qh->mq = mq;
+  qh->queue_id = ch->queue_gen++;
+  GNUNET_CONTAINER_DLL_insert (ch->queue_head, ch->queue_tail, qh);
+  send_add_queue (qh);
+  return qh;
+}
+
+
+void
+GNUNET_TRANSPORT_communicator_mq_update (
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch,
+  const struct GNUNET_TRANSPORT_QueueHandle *u_qh,
+  uint64_t q_len,
+  uint32_t priority)
+{
+  struct GNUNET_TRANSPORT_QueueHandle *qh;
+
+  for (qh = ch->queue_head; NULL != qh; qh = qh->next)
+  {
+    if (u_qh == qh)
+      break;
+  }
+  GNUNET_assert (NULL != qh);
+  qh->q_len = q_len;
+  qh->priority = priority;
+  send_update_queue (qh);
+}
+
+
+/**
+ * Notify transport service that an MQ became unavailable due to a
+ * disconnect or timeout.
+ *
+ * @param qh handle for the queue that must be invalidated
+ */
+void
+GNUNET_TRANSPORT_communicator_mq_del (struct GNUNET_TRANSPORT_QueueHandle *qh)
+{
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch = qh->ch;
+
+  send_del_queue (qh);
+  GNUNET_CONTAINER_DLL_remove (ch->queue_head, ch->queue_tail, qh);
+  GNUNET_MQ_destroy (qh->mq);
+  GNUNET_free (qh->address);
+  GNUNET_free (qh);
+}
+
+
+/**
+ * Notify transport service about an address that this communicator
+ * provides for this peer.
+ *
+ * @param ch connection to transport service
+ * @param address our address in human-readable format, 0-terminated, UTF-8
+ * @param nt which network type does the address belong to?
+ * @param expiration when does the communicator forsee this address expiring?
+ */
+struct GNUNET_TRANSPORT_AddressIdentifier *
+GNUNET_TRANSPORT_communicator_address_add (
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch,
+  const char *address,
+  enum GNUNET_NetworkType nt,
+  struct GNUNET_TIME_Relative expiration)
+{
+  struct GNUNET_TRANSPORT_AddressIdentifier *ai;
+
+  ai = GNUNET_new (struct GNUNET_TRANSPORT_AddressIdentifier);
+  ai->ch = ch;
+  ai->address = GNUNET_strdup (address);
+  ai->nt = nt;
+  ai->expiration = expiration;
+  ai->aid = ch->aid_gen++;
+  GNUNET_CONTAINER_DLL_insert (ch->ai_head, ch->ai_tail, ai);
+  send_add_address (ai);
+  return ai;
+}
+
+
+/**
+ * Notify transport service about an address that this communicator no
+ * longer provides for this peer.
+ *
+ * @param ai address that is no longer provided
+ */
+void
+GNUNET_TRANSPORT_communicator_address_remove (
+  struct GNUNET_TRANSPORT_AddressIdentifier *ai)
+{
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch = ai->ch;
+
+  send_del_address (ai);
+  GNUNET_CONTAINER_DLL_remove (ch->ai_head, ch->ai_tail, ai);
+  GNUNET_free (ai->address);
+  GNUNET_free (ai);
+  ai = NULL;
+}
+
+
+/**
+ * Notify transport service that this communicator no longer provides all its addresses for this peer.
+ *
+ * @param ch The communicator handle.
+ */
+void
+GNUNET_TRANSPORT_communicator_address_remove_all (
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
+{
+  struct GNUNET_TRANSPORT_AddressIdentifier *ai = ch->ai_head;
+  while (NULL != ai)
+  {
+    struct GNUNET_TRANSPORT_AddressIdentifier *ai_next = ai->next;
+    GNUNET_TRANSPORT_communicator_address_remove (ai);
+    ai = ai_next;
+  }
+}
+
+
+/* ************************* Backchannel *************************** */
+
+
+void
+GNUNET_TRANSPORT_communicator_notify (
+  struct GNUNET_TRANSPORT_CommunicatorHandle *ch,
+  const struct GNUNET_PeerIdentity *pid,
+  const char *comm,
+  const struct GNUNET_MessageHeader *header)
+{
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb;
+  size_t slen = strlen (comm) + 1;
+  uint16_t mlen = ntohs (header->size);
+
+  GNUNET_assert (mlen + slen + sizeof(*cb) < UINT16_MAX);
+  env =
+    GNUNET_MQ_msg_extra (cb,
+                         slen + mlen,
+                         GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL);
+  cb->pid = *pid;
+  memcpy (&cb[1], header, mlen);
+  memcpy (((char *) &cb[1]) + mlen, comm, slen);
+  GNUNET_MQ_send (ch->mq, env);
+}
+
+
+/* end of transport_api2_communication.c */
diff --git a/src/service/transport/transport_api2_core.c b/src/service/transport/transport_api2_core.c
new file mode 100644
index 000000000..598eef184
--- /dev/null
+++ b/src/service/transport/transport_api2_core.c
@@ -0,0 +1,845 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2009-2013, 2016, 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 transport/transport_api_core.c
+ * @brief library to access the transport service for message exchange
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_constants.h"
+#include "gnunet_arm_service.h"
+#include "gnunet_protocols.h"
+#include "gnunet_transport_core_service.h"
+#include "transport.h"
+
+#define LOG(kind, ...) GNUNET_log_from (kind, "transport-api-core", __VA_ARGS__)
+
+/**
+ * How large to start with for the hashmap of neighbours.
+ */
+#define STARTING_NEIGHBOURS_SIZE 16
+
+/**
+ * Window size. How many messages to the same target do we pass
+ * to TRANSPORT without a SEND_OK in between? Small values limit
+ * thoughput, large values will increase latency.
+ *
+ * FIXME-OPTIMIZE: find out what good values are experimentally,
+ * maybe set adaptively (i.e. to observed available bandwidth).
+ */
+#define SEND_WINDOW_SIZE 4
+
+
+/**
+ * Entry in hash table of all of our current (connected) neighbours.
+ */
+struct Neighbour
+{
+  /**
+   * Identity of this neighbour.
+   */
+  struct GNUNET_PeerIdentity id;
+
+  /**
+   * Overall transport handle.
+   */
+  struct GNUNET_TRANSPORT_CoreHandle *h;
+
+  /**
+   * Active message queue for the peer.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Envelope with the message we are currently transmitting (or NULL).
+   */
+  struct GNUNET_MQ_Envelope *env;
+
+  /**
+   * Closure for @e mq handlers.
+   */
+  void *handlers_cls;
+
+  /**
+   * How many messages can we still send to this peer before we should
+   * throttle?
+   */
+  unsigned int ready_window;
+
+  /**
+   * Used to indicate our status if @e env is non-NULL.  Set to
+   * #GNUNET_YES if we did pass a message to the MQ and are waiting
+   * for the call to #notify_send_done(). Set to #GNUNET_NO if the @e
+   * ready_window is 0 and @e env is waiting for a
+   * #GNUNET_MESSAGE_TYPE_TRANSPORT_RECV_OK?
+   */
+  int16_t awaiting_done;
+
+  /**
+   * Size of the message in @e env.
+   */
+  uint16_t env_size;
+};
+
+
+/**
+ * Handle for the transport service (includes all of the
+ * state for the transport service).
+ */
+struct GNUNET_TRANSPORT_CoreHandle
+{
+  /**
+   * Closure for the callbacks.
+   */
+  void *cls;
+
+  /**
+   * Functions to call for received data (template for
+   * new message queues).
+   */
+  struct GNUNET_MQ_MessageHandler *handlers;
+
+  /**
+   * function to call on connect events
+   */
+  GNUNET_TRANSPORT_NotifyConnect nc_cb;
+
+  /**
+   * function to call on disconnect events
+   */
+  GNUNET_TRANSPORT_NotifyDisconnect nd_cb;
+
+  /**
+   * My client connection to the transport service.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * My configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Hash map of the current connected neighbours of this peer.
+   * Maps peer identities to `struct Neighbour` entries.
+   */
+  struct GNUNET_CONTAINER_MultiPeerMap *neighbours;
+
+  /**
+   * Peer identity as assumed by this process, or all zeros.
+   */
+  struct GNUNET_PeerIdentity self;
+
+  /**
+   * ID of the task trying to reconnect to the service.
+   */
+  struct GNUNET_SCHEDULER_Task *reconnect_task;
+
+  /**
+   * Delay until we try to reconnect.
+   */
+  struct GNUNET_TIME_Relative reconnect_delay;
+
+  /**
+   * Transport connection started at.
+   */
+  struct GNUNET_TIME_Absolute restarted_at;
+
+  /**
+   * Should we check that @e self matches what the service thinks?
+   * (if #GNUNET_NO, then @e self is all zeros!).
+   */
+  int check_self;
+};
+
+
+/**
+ * Function that will schedule the job that will try
+ * to connect us again to the client.
+ *
+ * @param h transport service to reconnect
+ */
+static void
+disconnect_and_schedule_reconnect (struct GNUNET_TRANSPORT_CoreHandle *h);
+
+
+/**
+ * Get the neighbour list entry for the given peer
+ *
+ * @param h our context
+ * @param peer peer to look up
+ * @return NULL if no such peer entry exists
+ */
+static struct Neighbour *
+neighbour_find (struct GNUNET_TRANSPORT_CoreHandle *h,
+                const struct GNUNET_PeerIdentity *peer)
+{
+  return GNUNET_CONTAINER_multipeermap_get (h->neighbours, peer);
+}
+
+
+/**
+ * Iterator over hash map entries, for deleting state of a neighbour.
+ *
+ * @param cls the `struct GNUNET_TRANSPORT_CoreHandle *`
+ * @param key peer identity
+ * @param value value in the hash map, the neighbour entry to delete
+ * @return #GNUNET_YES if we should continue to
+ *         iterate,
+ *         #GNUNET_NO if not.
+ */
+static int
+neighbour_delete (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
+{
+  struct GNUNET_TRANSPORT_CoreHandle *handle = cls;
+  struct Neighbour *n = value;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Dropping entry for neighbour `%s'.\n",
+       GNUNET_i2s (key));
+  if (NULL != handle->nd_cb)
+    handle->nd_cb (handle->cls, &n->id, n->handlers_cls);
+  if (NULL != n->env)
+  {
+    GNUNET_MQ_send_cancel (n->env);
+    n->env = NULL;
+  }
+  GNUNET_MQ_destroy (n->mq);
+  GNUNET_assert (NULL == n->mq);
+  GNUNET_assert (
+    GNUNET_YES ==
+    GNUNET_CONTAINER_multipeermap_remove (handle->neighbours, key, n));
+  GNUNET_free (n);
+  return GNUNET_YES;
+}
+
+
+/**
+ * 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_TRANSPORT_CoreHandle *`
+ * @param error error code
+ */
+static void
+mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_TRANSPORT_CoreHandle *h = cls;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Error %u received from transport service, disconnecting temporarily.\n",
+       error);
+  disconnect_and_schedule_reconnect (h);
+}
+
+
+/**
+ * A message from the handler's message queue to a neighbour was
+ * transmitted.  Now trigger (possibly delayed) notification of the
+ * neighbour's message queue that we are done and thus ready for
+ * the next message.  Note that the MQ being ready is independent
+ * of the send window, as we may queue many messages and simply
+ * not pass them to TRANSPORT if the send window is insufficient.
+ *
+ * @param cls the `struct Neighbour` where the message was sent
+ */
+static void
+notify_send_done (void *cls)
+{
+  struct Neighbour *n = cls;
+
+  n->awaiting_done = GNUNET_NO;
+  n->env = NULL;
+  if (0 < n->ready_window)
+    GNUNET_MQ_impl_send_continue (n->mq);
+}
+
+
+/**
+ * We have an envelope waiting for transmission at @a n, and
+ * our transmission window is positive. Perform the transmission.
+ *
+ * @param n neighbour to perform transmission for
+ */
+static void
+do_send (struct Neighbour *n)
+{
+  GNUNET_assert (0 < n->ready_window);
+  GNUNET_assert (NULL != n->env);
+  n->ready_window--;
+  n->awaiting_done = GNUNET_YES;
+  GNUNET_MQ_notify_sent (n->env, &notify_send_done, n);
+  GNUNET_MQ_send (n->h->mq, n->env);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Passed message of type %u for neighbour `%s' to TRANSPORT. ready_window %u\n",
+       ntohs (GNUNET_MQ_env_get_msg (n->env)->type),
+       GNUNET_i2s (&n->id),
+       n->ready_window);
+}
+
+
+/**
+ * Implement sending functionality of a message queue.
+ * Called one message at a time. Should send the @a msg
+ * to the transport service and then notify the queue
+ * once we are ready for the next one.
+ *
+ * @param mq the message queue
+ * @param msg the message to send
+ * @param impl_state state of the implementation
+ */
+static void
+mq_send_impl (struct GNUNET_MQ_Handle *mq,
+              const struct GNUNET_MessageHeader *msg,
+              void *impl_state)
+{
+  struct Neighbour *n = impl_state;
+  struct OutboundMessage *obm;
+  uint16_t msize;
+
+  msize = ntohs (msg->size);
+  if (msize >= GNUNET_MAX_MESSAGE_SIZE - sizeof(*obm))
+  {
+    GNUNET_break (0);
+    GNUNET_MQ_impl_send_continue (mq);
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "CORE requested transmission of message of type %u to neighbour `%s'.\n",
+       ntohs (msg->type),
+       GNUNET_i2s (&n->id));
+
+  GNUNET_assert (NULL == n->env);
+  n->env =
+    GNUNET_MQ_msg_nested_mh (obm, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, msg);
+  n->env_size = ntohs (msg->size);
+  {
+    struct GNUNET_MQ_Envelope *env;
+
+    env = GNUNET_MQ_get_current_envelope (mq);
+    obm->priority = htonl ((uint32_t) GNUNET_MQ_env_get_options (env));
+  }
+  obm->peer = n->id;
+  if (0 == n->ready_window)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Flow control delays transmission to CORE until we see SEND_OK.\n");
+    return;   /* can't send yet, need to wait for SEND_OK */
+  }
+  do_send (n);
+}
+
+
+/**
+ * Handle destruction of a message queue.  Implementations must not
+ * free @a mq, but should take care of @a impl_state.
+ *
+ * @param mq the message queue to destroy
+ * @param impl_state state of the implementation
+ */
+static void
+mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
+{
+  struct Neighbour *n = impl_state;
+
+  GNUNET_assert (mq == n->mq);
+  n->mq = NULL;
+}
+
+
+/**
+ * Implementation function that cancels the currently sent message.
+ * Should basically undo whatever #mq_send_impl() did.
+ *
+ * @param mq message queue
+ * @param impl_state state specific to the implementation
+ */
+static void
+mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
+{
+  struct Neighbour *n = impl_state;
+
+  n->ready_window++;
+  if (GNUNET_YES == n->awaiting_done)
+  {
+    GNUNET_MQ_send_cancel (n->env);
+    n->env = NULL;
+    n->awaiting_done = GNUNET_NO;
+  }
+  else
+  {
+    GNUNET_assert (0 == n->ready_window);
+    n->env = NULL;
+  }
+}
+
+
+/**
+ * We had an error processing a message we forwarded from a peer to
+ * the CORE service.  We should just complain about it but otherwise
+ * continue processing.
+ *
+ * @param cls closure
+ * @param error error code
+ */
+static void
+peer_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
+{
+  struct Neighbour *n = cls;
+
+  if (GNUNET_MQ_ERROR_MALFORMED == error)
+    GNUNET_break_op (0);
+  //TODO Look into bug #7887
+
+  GNUNET_TRANSPORT_core_receive_continue (n->h, &n->id);
+}
+
+
+/**
+ * Function we use for handling incoming connect messages.
+ *
+ * @param cls closure, a `struct GNUNET_TRANSPORT_Handle *`
+ * @param cim message received
+ */
+static void
+handle_connect (void *cls, const struct ConnectInfoMessage *cim)
+{
+  struct GNUNET_TRANSPORT_CoreHandle *h = cls;
+  struct Neighbour *n;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Receiving CONNECT message for `%s'\n",
+       GNUNET_i2s (&cim->id));
+  n = neighbour_find (h, &cim->id);
+  if (NULL != n)
+  {
+    GNUNET_break (0);
+    disconnect_and_schedule_reconnect (h);
+    return;
+  }
+  n = GNUNET_new (struct Neighbour);
+  n->id = cim->id;
+  n->h = h;
+  n->ready_window = SEND_WINDOW_SIZE;
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multipeermap_put (
+                   h->neighbours,
+                   &n->id,
+                   n,
+                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+
+  n->mq = GNUNET_MQ_queue_for_callbacks (&mq_send_impl,
+                                         &mq_destroy_impl,
+                                         &mq_cancel_impl,
+                                         n,
+                                         h->handlers,
+                                         &peer_mq_error_handler,
+                                         n);
+  if (NULL != h->nc_cb)
+  {
+    n->handlers_cls = h->nc_cb (h->cls, &n->id, n->mq);
+    GNUNET_MQ_set_handlers_closure (n->mq, n->handlers_cls);
+  }
+}
+
+
+/**
+ * Function we use for handling incoming disconnect messages.
+ *
+ * @param cls closure, a `struct GNUNET_TRANSPORT_CoreHandle *`
+ * @param dim message received
+ */
+static void
+handle_disconnect (void *cls, const struct DisconnectInfoMessage *dim)
+{
+  struct GNUNET_TRANSPORT_CoreHandle *h = cls;
+  struct Neighbour *n;
+
+  GNUNET_break (ntohl (dim->reserved) == 0);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Receiving DISCONNECT message for `%s'.\n",
+       GNUNET_i2s (&dim->peer));
+  n = neighbour_find (h, &dim->peer);
+  if (NULL == n)
+  {
+    GNUNET_break (0);
+    disconnect_and_schedule_reconnect (h);
+    return;
+  }
+  GNUNET_assert (GNUNET_YES == neighbour_delete (h, &dim->peer, n));
+}
+
+
+/**
+ * Function we use for handling incoming send-ok messages.
+ *
+ * @param cls closure, a `struct GNUNET_TRANSPORT_CoreHandle *`
+ * @param okm message received
+ */
+static void
+handle_send_ok (void *cls, const struct SendOkMessage *okm)
+{
+  struct GNUNET_TRANSPORT_CoreHandle *h = cls;
+  struct Neighbour *n;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Receiving SEND_OK message for transmission to %s\n",
+       GNUNET_i2s (&okm->peer));
+
+  n = neighbour_find (h, &okm->peer);
+
+  if (NULL == n)
+  {
+    /* We should never get a 'SEND_OK' for a peer that we are not
+       connected to */
+    GNUNET_break (0);
+    disconnect_and_schedule_reconnect (h);
+    return;
+  }
+
+  if ((GNUNET_NO == n->awaiting_done) &&
+      (NULL != n->env) &&
+      (0 == n->ready_window))
+  {
+    n->ready_window++;
+    do_send (n);
+    return;
+  }
+  else if ((GNUNET_NO == n->awaiting_done) &&
+           (0 == n->ready_window))
+  {
+    n->ready_window++;
+    GNUNET_MQ_impl_send_continue (n->mq);
+    return;
+  }
+  n->ready_window++;
+}
+
+
+/**
+ * Function we use for checking incoming "inbound" messages.
+ *
+ * @param cls closure, a `struct GNUNET_TRANSPORT_CoreHandle *`
+ * @param im message received
+ */
+static int
+check_recv (void *cls, const struct InboundMessage *im)
+{
+  const struct GNUNET_MessageHeader *imm;
+  uint16_t size;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "check_recv\n");
+  size = ntohs (im->header.size) - sizeof(*im);
+  if (size < sizeof(struct GNUNET_MessageHeader))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  imm = (const struct GNUNET_MessageHeader *) &im[1];
+  if (ntohs (imm->size) != size)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Function we use for handling incoming messages.
+ *
+ * @param cls closure, a `struct GNUNET_TRANSPORT_CoreHandle *`
+ * @param im message received
+ */
+static void
+handle_recv (void *cls, const struct InboundMessage *im)
+{
+  struct GNUNET_TRANSPORT_CoreHandle *h = cls;
+  const struct GNUNET_MessageHeader *imm =
+    (const struct GNUNET_MessageHeader *) &im[1];
+  struct Neighbour *n;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received message of type %u with %u bytes from `%s'.\n",
+       (unsigned int) ntohs (imm->type),
+       (unsigned int) ntohs (imm->size),
+       GNUNET_i2s (&im->peer));
+  n = neighbour_find (h, &im->peer);
+  if (NULL == n)
+  {
+    GNUNET_break (0);
+    disconnect_and_schedule_reconnect (h);
+    return;
+  }
+  GNUNET_MQ_inject_message (n->mq, imm);
+}
+
+
+/**
+ * Try again to connect to transport service.
+ *
+ * @param cls the handle to the transport service
+ */
+static void
+reconnect (void *cls)
+{
+  struct GNUNET_TRANSPORT_CoreHandle *h = cls;
+  struct GNUNET_MQ_MessageHandler handlers[] =
+  { GNUNET_MQ_hd_fixed_size (connect,
+                             GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT,
+                             struct ConnectInfoMessage,
+                             h),
+    GNUNET_MQ_hd_fixed_size (disconnect,
+                             GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT,
+                             struct DisconnectInfoMessage,
+                             h),
+    GNUNET_MQ_hd_fixed_size (send_ok,
+                             GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK,
+                             struct SendOkMessage,
+                             h),
+    GNUNET_MQ_hd_var_size (recv,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_RECV,
+                           struct InboundMessage,
+                           h),
+    GNUNET_MQ_handler_end () };
+  struct GNUNET_MQ_Envelope *env;
+  struct StartMessage *s;
+  uint32_t options;
+
+  h->reconnect_task = NULL;
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service.\n");
+  GNUNET_assert (NULL == h->mq);
+  h->mq =
+    GNUNET_CLIENT_connect (h->cfg, "transport", handlers, &mq_error_handler, h);
+  h->restarted_at = GNUNET_TIME_absolute_get ();
+  if (NULL == h->mq)
+    return;
+  env = GNUNET_MQ_msg (s, GNUNET_MESSAGE_TYPE_TRANSPORT_START);
+  options = 0;
+  if (h->check_self)
+    options |= 1;
+  if (NULL != h->handlers)
+    options |= 2;
+  s->options = htonl (options);
+  s->self = h->self;
+  GNUNET_MQ_send (h->mq, env);
+}
+
+
+/**
+ * Disconnect from the transport service.
+ *
+ * @param h transport service to reconnect
+ */
+static void
+disconnect (struct GNUNET_TRANSPORT_CoreHandle *h)
+{
+  GNUNET_CONTAINER_multipeermap_iterate (h->neighbours, &neighbour_delete, h);
+  if (NULL != h->mq)
+  {
+    GNUNET_MQ_destroy (h->mq);
+    h->mq = NULL;
+  }
+}
+
+
+/**
+ * Function that will schedule the job that will try
+ * to connect us again to the client.
+ *
+ * @param h transport service to reconnect
+ */
+static void
+disconnect_and_schedule_reconnect (struct GNUNET_TRANSPORT_CoreHandle *h)
+{
+  GNUNET_assert (NULL == h->reconnect_task);
+  disconnect (h);
+  {
+    /* Reduce delay based on runtime of the connection,
+       so that there is a cool-down if a connection is up
+       for a while. */
+    struct GNUNET_TIME_Relative runtime;
+    unsigned int minutes;
+
+    runtime = GNUNET_TIME_absolute_get_duration (h->restarted_at);
+    minutes = runtime.rel_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us;
+    if (minutes > 31)
+      h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
+    else
+      h->reconnect_delay.rel_value_us >>= minutes;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Scheduling task to reconnect to transport service in %s.\n",
+       GNUNET_STRINGS_relative_time_to_string (h->reconnect_delay, GNUNET_YES));
+  h->reconnect_task =
+    GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
+  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
+}
+
+
+/**
+ * Checks if a given peer is connected to us and get the message queue.
+ *
+ * @param handle connection to transport service
+ * @param peer the peer to check
+ * @return NULL if disconnected, otherwise message queue for @a peer
+ */
+struct GNUNET_MQ_Handle *
+GNUNET_TRANSPORT_core_get_mq (struct GNUNET_TRANSPORT_CoreHandle *handle,
+                              const struct GNUNET_PeerIdentity *peer)
+{
+  struct Neighbour *n;
+
+  n = neighbour_find (handle, peer);
+  if (NULL == n)
+    return NULL;
+  return n->mq;
+}
+
+
+/**
+ * Notification from the CORE service to the TRANSPORT service
+ * that the CORE service has finished processing a message from
+ * TRANSPORT (via the @code{handlers} of #GNUNET_TRANSPORT_core_connect())
+ * and that it is thus now OK for TRANSPORT to send more messages
+ * for @a pid.
+ *
+ * Used to provide flow control, this is our equivalent to
+ * #GNUNET_SERVICE_client_continue() of an ordinary service.
+ *
+ * Note that due to the use of a window, TRANSPORT may send multiple
+ * messages destined for the same peer even without an intermediate
+ * call to this function. However, CORE must still call this function
+ * once per message received, as otherwise eventually the window will
+ * be full and TRANSPORT will stop providing messages to CORE for @a
+ * pid.
+ *
+ * @param ch core handle
+ * @param pid which peer was the message from that was fully processed by CORE
+ */
+void
+GNUNET_TRANSPORT_core_receive_continue (struct GNUNET_TRANSPORT_CoreHandle *ch,
+                                        const struct GNUNET_PeerIdentity *pid)
+{
+  struct GNUNET_MQ_Envelope *env;
+  struct RecvOkMessage *rok;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Message for %s finished CORE processing, sending RECV_OK.\n",
+       GNUNET_i2s (pid));
+  if (NULL == ch->mq)
+    return;
+  env = GNUNET_MQ_msg (rok, GNUNET_MESSAGE_TYPE_TRANSPORT_RECV_OK);
+  rok->increase_window_delta = htonl (1);
+  rok->peer = *pid;
+  GNUNET_MQ_send (ch->mq, env);
+}
+
+
+/**
+ * Connect to the transport service.  Note that the connection may
+ * complete (or fail) asynchronously.
+ *
+ * @param cfg configuration to use
+ * @param self our own identity (API should check that it matches
+ *             the identity found by transport), or NULL (no check)
+ * @param cls closure for the callbacks
+ * @param rec receive function to call
+ * @param nc function to call on connect events
+ * @param nd function to call on disconnect events
+ * @return NULL on error
+ */
+struct GNUNET_TRANSPORT_CoreHandle *
+GNUNET_TRANSPORT_core_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                               const struct GNUNET_PeerIdentity *self,
+                               const struct GNUNET_MQ_MessageHandler *handlers,
+                               void *cls,
+                               GNUNET_TRANSPORT_NotifyConnect nc,
+                               GNUNET_TRANSPORT_NotifyDisconnect nd)
+{
+  struct GNUNET_TRANSPORT_CoreHandle *h;
+  unsigned int i;
+
+  h = GNUNET_new (struct GNUNET_TRANSPORT_CoreHandle);
+  if (NULL != self)
+  {
+    h->self = *self;
+    h->check_self = GNUNET_YES;
+  }
+  h->cfg = cfg;
+  h->cls = cls;
+  h->nc_cb = nc;
+  h->nd_cb = nd;
+  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
+  if (NULL != handlers)
+  {
+    for (i = 0; NULL != handlers[i].cb; i++)
+      ;
+    h->handlers = GNUNET_new_array (i + 1, struct GNUNET_MQ_MessageHandler);
+    GNUNET_memcpy (h->handlers,
+                   handlers,
+                   i * sizeof(struct GNUNET_MQ_MessageHandler));
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service\n");
+  reconnect (h);
+  if (NULL == h->mq)
+  {
+    GNUNET_free (h->handlers);
+    GNUNET_free (h);
+    return NULL;
+  }
+  h->neighbours =
+    GNUNET_CONTAINER_multipeermap_create (STARTING_NEIGHBOURS_SIZE, GNUNET_YES);
+  return h;
+}
+
+
+/**
+ * Disconnect from the transport service.
+ *
+ * @param handle handle to the service as returned from
+ * #GNUNET_TRANSPORT_core_connect()
+ */
+void
+GNUNET_TRANSPORT_core_disconnect (struct GNUNET_TRANSPORT_CoreHandle *handle)
+{
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Transport disconnect called!\n");
+  /* this disconnects all neighbours... */
+  disconnect (handle);
+  /* and now we stop trying to connect again... */
+  if (NULL != handle->reconnect_task)
+  {
+    GNUNET_SCHEDULER_cancel (handle->reconnect_task);
+    handle->reconnect_task = NULL;
+  }
+  GNUNET_CONTAINER_multipeermap_destroy (handle->neighbours);
+  handle->neighbours = NULL;
+  GNUNET_free (handle->handlers);
+  handle->handlers = NULL;
+  GNUNET_free (handle);
+}
+
+
+/* end of transport_api_core.c */
diff --git a/src/service/transport/transport_api2_monitor.c b/src/service/transport/transport_api2_monitor.c
new file mode 100644
index 000000000..67aa1985e
--- /dev/null
+++ b/src/service/transport/transport_api2_monitor.c
@@ -0,0 +1,292 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 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 transport/transport_api2_monitor.c
+ * @brief implementation of the gnunet_transport_monitor_service.h API
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_transport_monitor_service.h"
+#include "transport.h"
+
+
+/**
+ * Opaque handle to the transport service for monitors.
+ */
+struct GNUNET_TRANSPORT_MonitorContext
+{
+  /**
+   * Our configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Queue to talk to the transport service.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Peer we monitor, all zeros for "all"
+   */
+  struct GNUNET_PeerIdentity peer;
+
+  /**
+   * #GNUNET_YES to return the current state and then end.
+   */
+  int one_shot;
+
+  /**
+   * Function to call with monitor data.
+   */
+  GNUNET_TRANSPORT_MonitorCallback cb;
+
+  /**
+   * Closure for @e cb.
+   */
+  void *cb_cls;
+};
+
+
+/**
+ * (re)connect our monitor to the transport service
+ *
+ * @param mc handle to reconnect
+ */
+static void
+reconnect (struct GNUNET_TRANSPORT_MonitorContext *mc);
+
+
+/**
+ * Send message to the transport service about our montoring
+ * desire.
+ *
+ * @param ai address to delete
+ */
+static void
+send_start_monitor (struct GNUNET_TRANSPORT_MonitorContext *mc)
+{
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_TRANSPORT_MonitorStart *smm;
+
+  if (NULL == mc->mq)
+    return;
+  env = GNUNET_MQ_msg (smm, GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_START);
+  smm->one_shot = htonl ((uint32_t) mc->one_shot);
+  smm->peer = mc->peer;
+  GNUNET_MQ_send (mc->mq, env);
+}
+
+
+/**
+ * Disconnect from the transport service.
+ *
+ * @param mc service to disconnect from
+ */
+static void
+disconnect (struct GNUNET_TRANSPORT_MonitorContext *mc)
+{
+  if (NULL == mc->mq)
+    return;
+  GNUNET_MQ_destroy (mc->mq);
+  mc->mq = NULL;
+}
+
+
+/**
+ * Function called on MQ errors. Reconnects to the service.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_MonitorContext *`
+ * @param error what error happened?
+ */
+static void
+error_handler (void *cls, enum GNUNET_MQ_Error error)
+{
+  struct GNUNET_TRANSPORT_MonitorContext *mc = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "MQ failure %d, reconnecting to transport service.\n",
+              error);
+  disconnect (mc);
+  /* TODO: maybe do this with exponential backoff/delay */
+  reconnect (mc);
+}
+
+
+/**
+ * Transport service sends us information about what is going on.
+ * Check if @a md is well-formed.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_MonitorContext *`
+ * @param md the monitor data we got
+ * @return #GNUNET_OK if @a smt is well-formed
+ */
+static int
+check_monitor_data (void *cls, const struct GNUNET_TRANSPORT_MonitorData *md)
+{
+  (void) cls;
+  GNUNET_MQ_check_zero_termination (md);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Transport service sends us information about what is going on.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_MonitorContext *`
+ * @param md monitor data
+ */
+static void
+handle_monitor_data (void *cls, const struct GNUNET_TRANSPORT_MonitorData *md)
+{
+  struct GNUNET_TRANSPORT_MonitorContext *mc = cls;
+  struct GNUNET_TRANSPORT_MonitorInformation mi;
+
+  mi.address = (const char *) &md[1];
+  mi.nt = (enum GNUNET_NetworkType) ntohl (md->nt);
+  mi.cs = (enum GNUNET_TRANSPORT_ConnectionStatus) ntohl (md->cs);
+  mi.num_msg_pending = ntohl (md->num_msg_pending);
+  mi.num_bytes_pending = ntohl (md->num_bytes_pending);
+  mi.last_validation = GNUNET_TIME_absolute_ntoh (md->last_validation);
+  mi.valid_until = GNUNET_TIME_absolute_ntoh (md->valid_until);
+  mi.next_validation = GNUNET_TIME_absolute_ntoh (md->next_validation);
+  mi.rtt = GNUNET_TIME_relative_ntoh (md->rtt);
+  mc->cb (mc->cb_cls, &md->peer, &mi);
+}
+
+
+/**
+ * One shot was requested, and transport service is done.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_MonitorContext *`
+ * @param me end message
+ */
+static void
+handle_monitor_end (void *cls, const struct GNUNET_MessageHeader *me)
+{
+  struct GNUNET_TRANSPORT_MonitorContext *mc = cls;
+
+  if (GNUNET_YES != mc->one_shot)
+  {
+    GNUNET_break (0);
+    disconnect (mc);
+    reconnect (mc);
+    return;
+  }
+  mc->cb (mc->cb_cls, NULL, NULL);
+  GNUNET_TRANSPORT_monitor_cancel (mc);
+}
+
+
+/**
+ * (re)connect our monitor to the transport service
+ *
+ * @param mc handle to reconnect
+ */
+static void
+reconnect (struct GNUNET_TRANSPORT_MonitorContext *mc)
+{
+  struct GNUNET_MQ_MessageHandler handlers[] =
+  { GNUNET_MQ_hd_var_size (monitor_data,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_DATA,
+                           struct GNUNET_TRANSPORT_MonitorData,
+                           mc),
+    GNUNET_MQ_hd_fixed_size (monitor_end,
+                             GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_END,
+                             struct GNUNET_MessageHeader,
+                             mc),
+    GNUNET_MQ_handler_end () };
+
+  mc->mq =
+    GNUNET_CLIENT_connect (mc->cfg, "transport", handlers, &error_handler, mc);
+  if (NULL == mc->mq)
+    return;
+  send_start_monitor (mc);
+}
+
+
+/**
+ * Return information about a specific peer or all peers currently known to
+ * transport service once or in monitoring mode. To obtain information about
+ * a specific peer, a peer identity can be passed. To obtain information about
+ * all peers currently known to transport service, NULL can be passed as peer
+ * identity.
+ *
+ * For each peer, the callback is called with information about the address used
+ * to communicate with this peer, the state this peer is currently in and the
+ * the current timeout for this state.
+ *
+ * Upon completion, the #GNUNET_TRANSPORT_PeerIterateCallback is called one
+ * more time with `NULL`. After this, the operation must no longer be
+ * explicitly canceled.
+ *
+ * The #GNUNET_TRANSPORT_monitor_peers_cancel call MUST not be called in the
+ * the peer_callback!
+ *
+ * @param cfg configuration to use
+ * @param peer a specific peer identity to obtain information for,
+ *      NULL for all peers
+ * @param one_shot #GNUNET_YES to return the current state and then end (with NULL+NULL),
+ *                 #GNUNET_NO to monitor peers continuously
+ * @param cb function to call with the results
+ * @param cb_cls closure for @a mc
+ */
+struct GNUNET_TRANSPORT_MonitorContext *
+GNUNET_TRANSPORT_monitor (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                          const struct GNUNET_PeerIdentity *peer,
+                          int one_shot,
+                          GNUNET_TRANSPORT_MonitorCallback cb,
+                          void *cb_cls)
+{
+  struct GNUNET_TRANSPORT_MonitorContext *mc;
+
+  mc = GNUNET_new (struct GNUNET_TRANSPORT_MonitorContext);
+  mc->cfg = cfg;
+  if (NULL != peer)
+    mc->peer = *peer;
+  mc->one_shot = one_shot;
+  mc->cb = cb;
+  mc->cb_cls = cb_cls;
+  reconnect (mc);
+  if (NULL == mc->mq)
+  {
+    GNUNET_free (mc);
+    return NULL;
+  }
+  return mc;
+}
+
+
+/**
+ * Cancel request to monitor peers
+ *
+ * @param pmc handle for the request to cancel
+ */
+void
+GNUNET_TRANSPORT_monitor_cancel (struct GNUNET_TRANSPORT_MonitorContext *mc)
+{
+  disconnect (mc);
+  GNUNET_free (mc);
+}
+
+
+/* end of transport_api2_monitor.c */
diff --git a/src/service/transport/transport_api_cmd_backchannel_check.c b/src/service/transport/transport_api_cmd_backchannel_check.c
new file mode 100644
index 000000000..6fa61adb7
--- /dev/null
+++ b/src/service/transport/transport_api_cmd_backchannel_check.c
@@ -0,0 +1,554 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testing_api_cmd_backchannel_check.c
+ * @brief cmd to start a peer.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_ng_lib.h"
+#include "gnunet_testing_netjail_lib.h"
+#include "gnunet_transport_application_service.h"
+#include "transport-testing-cmds.h"
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind, ...) GNUNET_log_from (kind, "udp-backchannel",__VA_ARGS__)
+
+#define UDP "udp"
+
+/**
+ * Maximum length allowed for line input.
+ */
+#define MAX_LINE_LENGTH 1024
+
+/**
+ * Struct to store information needed in callbacks.
+ *
+ */
+struct CheckState
+{
+  /**
+   * Context for our asynchronous completion.
+   */
+  struct GNUNET_TESTING_AsyncContext ac;
+
+  /**
+   * The number of the node in a network namespace.
+   */
+  unsigned int node_n;
+
+  /**
+   * The number of the network namespace.
+   */
+  unsigned int namespace_n;
+
+  /**
+   * The testing system of this node.
+   */
+  const struct GNUNET_TESTBED_System *tl_system;
+
+  // Label of the cmd which started the test system.
+  const char *create_label;
+
+  /**
+   * Number globally identifying the node.
+   *
+   */
+  uint32_t num;
+
+  /**
+   * Label of the cmd to start a peer.
+   *
+   */
+  const char *start_peer_label;
+
+  /**
+   * The topology of the test setup.
+   */
+  struct GNUNET_TESTING_NetjailTopology *topology;
+
+  /**
+   * Connections to other peers.
+   */
+  struct GNUNET_TESTING_NodeConnection *node_connections_head;
+
+  /**
+   * Number of connections.
+   */
+  unsigned int con_num;
+
+  /**
+   * Number of received backchannel messages.
+   */
+  unsigned int received_backchannel_msgs;
+
+  /**
+   * Array with search strings.
+   */
+  char **search_string;
+
+  /**
+   * File handle for log file.
+   */
+  struct GNUNET_DISK_FileHandle *fh;
+
+  /**
+   * Task which handles the reading
+   */
+  struct GNUNET_SCHEDULER_Task *task;
+
+  /**
+   * Stream to read log file lines.
+   */
+  FILE *stream;
+};
+
+/**
+ *
+ * @param cls The cmd state CheckState.
+ */
+static void
+read_from_log (void *cls)
+{
+  struct CheckState *cs = cls;
+  char line[MAX_LINE_LENGTH + 1];
+  char *search_string;
+
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "read_from_log\n");
+
+  cs->fh = GNUNET_DISK_file_open ("test.out",
+                                  GNUNET_DISK_OPEN_READ,
+                                  GNUNET_DISK_PERM_USER_READ);
+
+  cs->task = NULL;
+
+  /* read message from line and handle it */
+  cs->stream = fdopen (cs->fh->fd, "r");
+  memset (line, 0, MAX_LINE_LENGTH + 1);
+
+  // fgets (line, MAX_LINE_LENGTH, cs->stream);
+  // while (NULL != line &&  0 != strcmp (line, ""))// '\0' != line[0])
+  while  (NULL != fgets (line, MAX_LINE_LENGTH, cs->stream))
+  {
+    /*LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "cs->received_backchannel_msgs: %u\n",
+         cs->received_backchannel_msgs);*/
+    /*if (NULL == strstr (line, "line"))
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "line: %s",
+           line);*/
+
+
+    for (int i = 0; i < cs->con_num; i++)
+    {
+      search_string = cs->search_string[i];
+      /*LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "search %u %u: %s %p\n",
+           i,
+           cs->con_num,
+           cs->search_string[i],
+           cs->search_string);
+      fprintf (stderr,
+      line);*/
+      if (NULL != strstr (line,
+                          search_string))
+      // "Delivering backchannel message from 4TTC to F7B5 of type 1460 to udp"))
+      // cs->search_string[i]))
+      {
+        cs->received_backchannel_msgs++;
+        LOG (GNUNET_ERROR_TYPE_DEBUG,
+             "received_backchannel_msgs %u con_num %u\n",
+             cs->received_backchannel_msgs,
+             cs->con_num);
+        if (cs->received_backchannel_msgs == cs->con_num)
+        {
+          LOG (GNUNET_ERROR_TYPE_DEBUG,
+               "search finished %lu %lu %u\n",
+               strlen (cs->search_string[i]),
+               strlen (
+                 "Delivering backchannel message from 4TTC to F7B5 of type 1460 to udp"),
+               strcmp (
+                 "Delivering backchannel message from 4TTC to F7B5 of type 1460 to udp",
+                 cs->search_string[i]));
+          GNUNET_TESTING_async_finish (&cs->ac);
+          fclose (cs->stream);
+          return;
+        }
+      }
+    }
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "read_from_log end\n");
+  fclose (cs->stream);
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
+                                &read_from_log,
+                                cs);
+  /*if (NULL == fgets (line, MAX_LINE_LENGTH, cs->stream))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "read null\n");
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                  &read_from_log,
+                                  cs);
+    return;
+    }*/
+  /*else {
+    cs->task =
+      GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                      cs->fh,
+                                      &read_from_log,
+                                      cs);
+
+
+                                      }*/
+}
+
+
+static enum GNUNET_GenericReturnValue
+will_the_other_node_connect_via_udp (
+  struct CheckState *cs,
+  const struct GNUNET_TESTING_NetjailNode *node)
+// struct GNUNET_TESTING_NodeConnection *connection)
+{
+  // struct GNUNET_TESTING_NetjailTopology *topology = cs->topology;
+  // unsigned int node_n = connection->node_n;
+  // unsigned int namespace_n = connection->namespace_n;
+  // struct GNUNET_HashCode hc;
+  // struct GNUNET_ShortHashCode *key = GNUNET_new (struct GNUNET_ShortHashCode);
+  // struct GNUNET_HashCode hc_namespace;
+  /*struct GNUNET_ShortHashCode *key_namespace = GNUNET_new (struct
+    GNUNET_ShortHashCode);*/
+  // struct GNUNET_TESTING_NetjailNode *node;
+  struct GNUNET_TESTING_NodeConnection *pos_connection;
+  struct GNUNET_TESTING_AddressPrefix *pos_prefix;
+  // struct GNUNET_TESTING_NetjailNamespace *namespace;
+  // struct GNUNET_CONTAINER_MultiShortmap *map;
+
+  /* if (0 == connection->namespace_n) */
+  /* { */
+  /*   map = topology->map_globals; */
+  /* } */
+  /* else */
+  /* { */
+  /*   GNUNET_CRYPTO_hash (&namespace_n, sizeof(namespace_n), &hc_namespace); */
+  /*   memcpy (key_namespace, */
+  /*           &hc_namespace, */
+  /*           sizeof (*key_namespace)); */
+  /*   if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_contains ( */
+  /*         topology->map_namespaces, */
+  /*         key_namespace)) */
+  /*   { */
+  /*     namespace = GNUNET_CONTAINER_multishortmap_get (topology->map_namespaces, */
+  /*                                                     key_namespace); */
+  /*     map = namespace->nodes; */
+  /*   } */
+  /*   else */
+  /*     GNUNET_assert (0); */
+  /* } */
+
+  /* GNUNET_CRYPTO_hash (&node_n, sizeof(node_n), &hc); */
+  /* memcpy (key, */
+  /*         &hc, */
+  /*         sizeof (*key)); */
+  /* if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_contains ( */
+  /*       map, */
+  /*       key)) */
+  /* { */
+  /*   node = GNUNET_CONTAINER_multishortmap_get (cs->topology->map_globals, */
+  /*                                              key); */
+  /*   for (pos_connection = node->node_connections_head; NULL != pos_connection; */
+  /*        pos_connection = pos_connection->next) */
+  /*   { */
+  /*     if ((node->namespace_n == pos_connection->namespace_n) && */
+  /*         (node->node_n == pos_connection->node_n) ) */
+  /*     { */
+  /*       for (pos_prefix = pos_connection->address_prefixes_head; NULL != */
+  /*            pos_prefix; */
+  /*            pos_prefix = */
+  /*              pos_prefix->next) */
+  /*       { */
+  /*         if (0 == strcmp (UDP, pos_prefix->address_prefix)) */
+  /*         { */
+  /*           return GNUNET_YES; */
+  /*         } */
+  /*       } */
+  /*     } */
+  /*   } */
+  /* } */
+
+  for (pos_connection = node->node_connections_head; NULL != pos_connection;
+       pos_connection = pos_connection->next)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "connect via udp %u %u %u %u\n",
+                node->namespace_n,
+                cs->namespace_n,
+                node->node_n,
+                cs->node_n);
+    if ((pos_connection->namespace_n == cs->namespace_n) &&
+        (pos_connection->node_n == cs->node_n) )
+    {
+      for (pos_prefix = pos_connection->address_prefixes_head; NULL !=
+           pos_prefix;
+           pos_prefix =
+             pos_prefix->next)
+      {
+        if (0 == strcmp (UDP, pos_prefix->address_prefix))
+        {
+          return GNUNET_YES;
+        }
+      }
+    }
+  }
+
+  return GNUNET_NO;
+}
+
+
+static void
+add_search_string (struct CheckState *cs, const struct
+                   GNUNET_TESTING_NetjailNode *node)
+{
+  unsigned int num;
+  struct GNUNET_PeerIdentity *peer;
+  struct GNUNET_PeerIdentity *us;
+  char *buf;
+  char *part_one = "Delivering backchannel message from ";
+  char *part_two = " to ";
+  char *part_three = " of type 1460 to udp";
+  char *peer_id;
+  char *us_id;
+
+  if (0 == node->namespace_n)
+    num = node->node_n;
+  else
+    num = (node->namespace_n - 1) * cs->topology->nodes_m + node->node_n
+          + cs->topology->nodes_x;
+
+  // num = GNUNET_TESTING_calculate_num (pos_connection, cs->topology);
+  peer = GNUNET_TESTING_get_peer (num, cs->tl_system);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "peer: %s num %u\n",
+       GNUNET_i2s (peer),
+       num);
+  us = GNUNET_TESTING_get_peer (cs->num, cs->tl_system);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "us: %s cs->num %d\n",
+       GNUNET_i2s (us),
+       cs->num);
+
+  GNUNET_asprintf (&peer_id,
+                   "%s",
+                   GNUNET_i2s (peer));
+  GNUNET_asprintf (&us_id,
+                   "%s",
+                   GNUNET_i2s (us));
+
+  if (0 < GNUNET_asprintf (&buf,
+                           "%s%s%s%s%s",
+                           part_one,
+                           us_id,
+                           part_two,
+                           peer_id,
+                           part_three))
+  {
+    GNUNET_array_append (cs->search_string,
+                         cs->con_num,
+                         buf);
+    /*LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "con_num: %u search: %s %p\n",
+         cs->con_num,
+         cs->search_string[cs->con_num - 1],
+         cs->search_string);*/
+  }
+  else
+    GNUNET_assert (0);
+  GNUNET_free (peer);
+  GNUNET_free (us);
+}
+
+
+/**
+ * The run method of this cmd will connect to peers.
+ *
+ */
+static void
+backchannel_check_run (void *cls,
+                       struct GNUNET_TESTING_Interpreter *is)
+{
+  struct CheckState *cs = cls;
+  const struct GNUNET_TESTING_Command *system_cmd;
+  const struct GNUNET_TESTBED_System *tl_system;
+  const struct GNUNET_TESTING_Command *peer1_cmd;
+  const struct GNUNET_TRANSPORT_ApplicationHandle *ah;
+  struct GNUNET_CONTAINER_MultiShortmapIterator *node_it;
+  struct GNUNET_CONTAINER_MultiShortmapIterator *namespace_it;
+  struct GNUNET_ShortHashCode node_key;
+  struct GNUNET_ShortHashCode namespace_key;
+  const struct GNUNET_TESTING_NetjailNode *node;
+  const struct GNUNET_TESTING_NetjailNamespace *namespace;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "check run 1\n");
+
+  peer1_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                         cs->start_peer_label);
+  GNUNET_TRANSPORT_TESTING_get_trait_application_handle (peer1_cmd,
+                                                         &ah);
+
+  system_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                          cs->create_label);
+  GNUNET_TESTING_get_trait_test_system (system_cmd,
+                                        &tl_system);
+
+  cs->tl_system = tl_system;
+
+  cs->node_connections_head = GNUNET_TESTING_get_connections (cs->num,
+                                                              cs->topology);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "check run 2\n");
+
+
+  node_it = GNUNET_CONTAINER_multishortmap_iterator_create (
+    cs->topology->map_globals);
+
+  while (GNUNET_YES == GNUNET_CONTAINER_multishortmap_iterator_next (node_it,
+                                                                     &node_key,
+                                                                     (const
+                                                                      void**) &
+                                                                     node))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "namespace_n %u node_n %u\n",
+         node->namespace_n,
+         node->node_n);
+    if (GNUNET_YES == will_the_other_node_connect_via_udp (cs, node))
+    {
+      add_search_string (cs, node);
+    }
+  }
+  GNUNET_free (node_it);
+  namespace_it = GNUNET_CONTAINER_multishortmap_iterator_create (
+    cs->topology->map_namespaces);
+  while (GNUNET_YES == GNUNET_CONTAINER_multishortmap_iterator_next (
+           namespace_it,
+           &namespace_key,
+           (const
+            void**) &namespace))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "namespace_n %u\n",
+         node->namespace_n);
+    node_it = GNUNET_CONTAINER_multishortmap_iterator_create (
+      namespace->nodes);
+    while (GNUNET_YES == GNUNET_CONTAINER_multishortmap_iterator_next (node_it,
+                                                                       &node_key
+                                                                       ,
+                                                                       (const
+                                                                        void**)
+                                                                       &node))
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "namespace_n %u node_n %u\n",
+           node->namespace_n,
+           node->node_n);
+      if (GNUNET_YES == will_the_other_node_connect_via_udp (cs, node))
+      {
+        add_search_string (cs, node);
+      }
+    }
+    GNUNET_free (node_it);
+  }
+
+  if (0 != cs->con_num)
+  {
+    cs->task =
+      GNUNET_SCHEDULER_add_now (&read_from_log,
+                                cs);
+  }
+  else
+    GNUNET_TESTING_async_finish (&cs->ac);
+
+  GNUNET_free (namespace_it);
+}
+
+
+/**
+ * Trait function of this cmd does nothing.
+ *
+ */
+static int
+backchannel_check_traits (void *cls,
+                          const void **ret,
+                          const char *trait,
+                          unsigned int index)
+{
+  return GNUNET_OK;
+}
+
+
+/**
+ * The cleanup function of this cmd frees resources the cmd allocated.
+ *
+ */
+static void
+backchannel_check_cleanup (void *cls)
+{
+  struct ConnectPeersState *cs = cls;
+
+  GNUNET_free (cs);
+}
+
+
+struct GNUNET_TESTING_Command
+GNUNET_TRANSPORT_cmd_backchannel_check (const char *label,
+                                        const char *start_peer_label,
+                                        const char *create_label,
+                                        uint32_t num,
+                                        unsigned int node_n,
+                                        unsigned int namespace_n,
+                                        struct GNUNET_TESTING_NetjailTopology *
+                                        topology)
+{
+  struct CheckState *cs;
+
+  cs = GNUNET_new (struct CheckState);
+  cs->start_peer_label = start_peer_label;
+  cs->num = num;
+  cs->create_label = create_label;
+  cs->topology = topology;
+  cs->node_n = node_n;
+  cs->namespace_n = namespace_n;
+
+  return GNUNET_TESTING_command_new_ac (cs,
+                                        label,
+                                        &backchannel_check_run,
+                                        &backchannel_check_cleanup,
+                                        &backchannel_check_traits,
+                                        &cs->ac);
+}
diff --git a/src/service/transport/transport_api_cmd_connecting_peers.c b/src/service/transport/transport_api_cmd_connecting_peers.c
new file mode 100644
index 000000000..280c0e9a2
--- /dev/null
+++ b/src/service/transport/transport_api_cmd_connecting_peers.c
@@ -0,0 +1,315 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testing_api_cmd_start_peer.c
+ * @brief cmd to start a peer.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_testbed_lib.h"
+#include "gnunet_transport_testing_ng_lib.h"
+#include "transport-testing-cmds.h"
+#include "gnunet_transport_application_service.h"
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
+
+/**
+ * The run method of this cmd will connect to peers.
+ *
+ */
+static void
+connect_peers_run (void *cls,
+                   struct GNUNET_TESTING_Interpreter *is)
+{
+  struct ConnectPeersState *cps = cls;
+  const struct GNUNET_TESTING_Command *system_cmd;
+  const struct GNUNET_TESTBED_System *tl_system;
+
+
+  const struct GNUNET_TESTING_Command *peer1_cmd;
+  const struct GNUNET_TRANSPORT_ApplicationHandle *ah;
+  struct GNUNET_PeerIdentity *peer;
+  char *addr;
+  char *addr_and_port;
+  enum GNUNET_NetworkType nt = 0;
+  uint32_t num;
+  struct GNUNET_TESTING_NodeConnection *pos_connection;
+  struct GNUNET_TESTING_AddressPrefix *pos_prefix;
+  unsigned int con_num = 0;
+  const enum GNUNET_GenericReturnValue *broadcast;
+
+  cps->is = is;
+  peer1_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                         cps->start_peer_label);
+  if (GNUNET_YES == cps->wait_for_connect)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Wait for connect.\n");
+    GNUNET_TRANSPORT_TESTING_get_trait_application_handle (peer1_cmd,
+                                                           &ah);
+  }
+  else
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Not waiting for connect.\n");
+    GNUNET_TRANSPORT_TESTING_get_trait_application_handle (peer1_cmd,
+                                                           &ah);
+  }
+
+  GNUNET_TRANSPORT_TESTING_get_trait_broadcast (peer1_cmd,
+                                                &broadcast);
+
+  system_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                          cps->create_label);
+  GNUNET_TESTBED_get_trait_test_system (system_cmd,
+                                        &tl_system);
+
+  cps->tl_system = tl_system;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "cps->num: %u \n",
+       cps->num);
+
+  cps->node_connections_head = GNUNET_TESTING_get_connections (cps->num,
+                                                               cps->topology);
+
+  for (pos_connection = cps->node_connections_head; NULL != pos_connection;
+       pos_connection = pos_connection->next)
+  {
+    con_num++;
+    num = GNUNET_TESTING_calculate_num (pos_connection, cps->topology);
+    for (pos_prefix = pos_connection->address_prefixes_head; NULL != pos_prefix;
+         pos_prefix =
+           pos_prefix->next)
+    {
+      addr = GNUNET_TESTING_get_address (pos_connection,
+                                         pos_prefix->address_prefix);
+      if (NULL != addr)
+      {
+        char *natted_p = strstr (pos_prefix->address_prefix, "_");
+
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "0 validating peer number %s %s %s\n",
+                    natted_p,
+                    pos_prefix->address_prefix,
+                    addr);
+        if (0 == GNUNET_memcmp (pos_prefix->address_prefix, "udp"))
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "validating memcmp\n");
+        if (GNUNET_YES == *broadcast)
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "validating broadcast\n");
+        if ((0 == GNUNET_memcmp (pos_prefix->address_prefix, "udp")) &&
+            (GNUNET_YES == *broadcast) )
+          GNUNET_asprintf (&addr_and_port,
+                           "%s:2086",
+                           addr);
+        else if (NULL == natted_p)
+          GNUNET_asprintf (&addr_and_port,
+                           "%s:60002",
+                           addr);
+        else if (NULL != natted_p)
+        {
+          char *prefix;
+          char *rest;
+          char *address;
+
+          prefix = strtok (addr, "_");
+          rest = strtok (NULL, "_");
+          strtok (rest, "-");
+          address = strtok (NULL, "-");
+
+          GNUNET_asprintf (&addr_and_port,
+                           "%s-%s:0",
+                           prefix,
+                           address);
+
+        }
+        peer = GNUNET_TESTING_get_peer (num, tl_system);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "validating peer number %u with identity %s and address %s %u %s and handle %p\n",
+                    num,
+                    GNUNET_i2s (peer),
+                    addr_and_port,
+                    *broadcast,
+                    pos_prefix->address_prefix,
+                    ah);
+        GNUNET_TRANSPORT_application_validate ((struct
+                                                GNUNET_TRANSPORT_ApplicationHandle
+                                                *) ah,
+                                               peer,
+                                               nt,
+                                               addr_and_port);
+        GNUNET_free (peer);
+        GNUNET_free (addr);
+        GNUNET_free (addr_and_port);
+      }
+    }
+  }
+  cps->con_num = con_num;
+}
+
+
+/**
+ * Callback from start peer cmd for signaling a peer got connected.
+ *
+ */
+static void *
+notify_connect (struct GNUNET_TESTING_Interpreter *is,
+                const struct GNUNET_PeerIdentity *peer)
+{
+  const struct GNUNET_TESTING_Command *cmd;
+  struct ConnectPeersState *cps;
+  struct GNUNET_PeerIdentity *peer_connection;
+  unsigned int num;
+  unsigned int con_num;
+  void *ret = NULL;
+
+  cmd = GNUNET_TESTING_interpreter_lookup_command_all (is,
+                                                       "connect-peers");
+  cps = cmd->cls; // WTF? Never go directly into cls of another command! FIXME!
+  con_num = cps->con_num_notified;
+  for (struct GNUNET_TESTING_NodeConnection *pos_connection =
+         cps->node_connections_head;
+       NULL != pos_connection;
+       pos_connection = pos_connection->next)
+  {
+    num = GNUNET_TESTING_calculate_num (pos_connection,
+                                        cps->topology);
+    peer_connection = GNUNET_TESTING_get_peer (num,
+                                               cps->tl_system);
+    if (0 == GNUNET_memcmp (peer,
+                            peer_connection))
+      cps->con_num_notified++;
+    GNUNET_free (peer_connection);
+  }
+  if (cps->con_num_notified == con_num)
+    cps->additional_connects_notified++;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "con_num: %u add: %u num_notified: %u add_notified: %u peer: %s\n",
+              cps->con_num,
+              cps->additional_connects,
+              cps->con_num_notified,
+              cps->additional_connects_notified,
+              GNUNET_i2s (peer));
+  if ((cps->con_num == cps->con_num_notified) &&
+      (cps->additional_connects <= cps->additional_connects_notified))
+  {
+    GNUNET_TESTING_async_finish (&cps->ac);
+  }
+  return ret;
+}
+
+
+/**
+ * The cleanup function of this cmd frees resources the cmd allocated.
+ *
+ */
+static void
+connect_peers_cleanup (void *cls)
+{
+  struct ConnectPeersState *cps = cls;
+
+  GNUNET_free (cps);
+}
+
+
+/**
+ * This function prepares an array with traits.
+ *
+ */
+enum GNUNET_GenericReturnValue
+connect_peers_traits (void *cls,
+                      const void **ret,
+                      const char *trait,
+                      unsigned int index)
+{
+  struct ConnectPeersState *cps = cls;
+  struct GNUNET_TESTING_Trait traits[] = {
+    GNUNET_TRANSPORT_TESTING_make_trait_connect_peer_state ((const void *) cps),
+    GNUNET_TESTING_trait_end ()
+  };
+  return GNUNET_TESTING_get_trait (traits,
+                                   ret,
+                                   trait,
+                                   index);
+}
+
+
+struct GNUNET_TESTING_Command
+GNUNET_TRANSPORT_cmd_connect_peers (const char *label,
+                                    const char *start_peer_label,
+                                    const char *create_label,
+                                    uint32_t num,
+                                    struct GNUNET_TESTING_NetjailTopology *
+                                    topology,
+                                    unsigned int additional_connects,
+                                    unsigned int wait_for_connect)
+{
+  struct ConnectPeersState *cps;
+  unsigned int node_additional_connects;
+
+  node_additional_connects = GNUNET_TESTING_get_additional_connects (num,
+                                                                     topology);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "global: %u and local: %u additional_connects\n",
+       additional_connects,
+       node_additional_connects);
+
+  if (0 != node_additional_connects)
+    additional_connects = node_additional_connects;
+
+  cps = GNUNET_new (struct ConnectPeersState);
+  cps->start_peer_label = start_peer_label;
+  cps->num = num;
+  cps->create_label = create_label;
+  cps->topology = topology;
+  cps->notify_connect = notify_connect;
+  cps->additional_connects = additional_connects;
+  cps->wait_for_connect = wait_for_connect;
+
+  // FIXME: wrap with cmd_make_unblocking!
+  if (GNUNET_YES == wait_for_connect)
+    return GNUNET_TESTING_command_new_ac (cps,
+                                          label,
+                                          &connect_peers_run,
+                                          &connect_peers_cleanup,
+                                          &connect_peers_traits,
+                                          &cps->ac);
+  else
+    return GNUNET_TESTING_command_new (cps,
+                                       label,
+                                       &connect_peers_run,
+                                       &connect_peers_cleanup,
+                                       &connect_peers_traits);
+}
+
+
+// FIXME: likely not ideally placed here, move to its own file
+GNUNET_TRANSPORT_TESTING_SIMPLE_TRAITS (GNUNET_TESTING_MAKE_IMPL_SIMPLE_TRAIT,
+                                        GNUNET_TRANSPORT_TESTING)
diff --git a/src/service/transport/transport_api_cmd_send_simple.c b/src/service/transport/transport_api_cmd_send_simple.c
new file mode 100644
index 000000000..b0f443584
--- /dev/null
+++ b/src/service/transport/transport_api_cmd_send_simple.c
@@ -0,0 +1,161 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testing_api_cmd_start_peer.c
+ * @brief cmd to start a peer.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_ng_lib.h"
+#include "gnunet_testing_netjail_lib.h"
+#include "transport-testing2.h"
+#include "transport-testing-cmds.h"
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
+
+/**
+ * Struct to hold information for callbacks.
+ *
+ */
+struct SendSimpleState
+{
+  /**
+   * Number globally identifying the node.
+   *
+   */
+  uint32_t num;
+
+  /**
+   * Label of the cmd to start a peer.
+   *
+   */
+  const char *start_peer_label;
+
+  /**
+   * Label of the cmd which started the test system.
+   *
+   */
+  const char *create_label;
+
+  /**
+   * The topology we get the connected nodes from.
+   */
+  struct GNUNET_TESTING_NetjailTopology *topology;
+};
+
+
+/**
+ * The cleanup function of this cmd frees resources the cmd allocated.
+ *
+ */
+static void
+send_simple_cleanup (void *cls)
+{
+  struct SendSimpleState *sss = cls;
+
+  GNUNET_free (sss);
+}
+
+
+static int
+send_simple_cb  (void *cls,
+                 const struct GNUNET_ShortHashCode *key,
+                 void *value)
+{
+  struct SendSimpleState *sss = cls;
+  struct GNUNET_MQ_Handle *mq = value;
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_TRANSPORT_TESTING_TestMessage *test;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Sending simple test message with mq %p\n",
+       mq);
+
+  env = GNUNET_MQ_msg_extra (test,
+                             1000 - sizeof(*test),
+                             GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE);
+  test->num = htonl (sss->num);
+  memset (&test[1],
+          sss->num,
+          1000 - sizeof(*test));
+  GNUNET_MQ_send (mq,
+                  env);
+  return GNUNET_OK;
+}
+
+
+/**
+ * The run method of this cmd will send a simple message to the connected peers.
+ *
+ */
+static void
+send_simple_run (void *cls,
+                 struct GNUNET_TESTING_Interpreter *is)
+{
+  struct SendSimpleState *sss = cls;
+  const struct GNUNET_CONTAINER_MultiShortmap *connected_peers_map;
+  const struct GNUNET_TESTING_Command *peer1_cmd;
+  const struct GNUNET_TESTING_Command *system_cmd;
+  const struct GNUNET_TESTBED_System *tl_system;
+
+  peer1_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                         sss->start_peer_label);
+  GNUNET_TRANSPORT_TESTING_get_trait_connected_peers_map (peer1_cmd,
+                                                          &connected_peers_map);
+
+  system_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                          sss->create_label);
+  GNUNET_TESTING_get_trait_test_system (system_cmd,
+                                        &tl_system);
+
+  GNUNET_CONTAINER_multishortmap_iterate (
+    (struct GNUNET_CONTAINER_MultiShortmap *)
+    connected_peers_map, send_simple_cb,
+    sss);
+}
+
+
+struct GNUNET_TESTING_Command
+GNUNET_TRANSPORT_cmd_send_simple (const char *label,
+                                  const char *start_peer_label,
+                                  const char *create_label,
+                                  uint32_t num,
+                                  struct GNUNET_TESTING_NetjailTopology *
+                                  topology)
+{
+  struct SendSimpleState *sss;
+
+  sss = GNUNET_new (struct SendSimpleState);
+  sss->num = num;
+  sss->start_peer_label = start_peer_label;
+  sss->create_label = create_label;
+  sss->topology = topology;
+
+  return GNUNET_TESTING_command_new (sss,
+                                     label,
+                                     &send_simple_run,
+                                     &send_simple_cleanup,
+                                     NULL);
+}
diff --git a/src/service/transport/transport_api_cmd_send_simple_performance.c b/src/service/transport/transport_api_cmd_send_simple_performance.c
new file mode 100644
index 000000000..a3012d9cd
--- /dev/null
+++ b/src/service/transport/transport_api_cmd_send_simple_performance.c
@@ -0,0 +1,219 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testing_api_cmd_start_peer.c
+ * @brief cmd to start a peer.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_ng_lib.h"
+#include "gnunet_testing_netjail_lib.h"
+#include "transport-testing2.h"
+#include "transport-testing-cmds.h"
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
+
+/**
+ * Struct to hold information for callbacks.
+ *
+ */
+struct SendSimplePerfState
+{
+  /**
+   * Context for our asynchronous completion.
+   */
+  struct GNUNET_TESTING_AsyncContext ac;
+
+  /**
+   * Label of the cmd to start a peer.
+   *
+   */
+  const char *start_peer_label;
+
+  /**
+   * Label of the cmd which started the test system.
+   *
+   */
+  const char *create_label;
+
+  /**
+   * The topology we get the connected nodes from.
+   */
+  struct GNUNET_TESTING_NetjailTopology *topology;
+
+  /**
+   * Size of the message in bytes.
+   */
+  unsigned int size;
+
+  /**
+   * Maximum number of messages per peer.
+   */
+  unsigned int max_send;
+};
+
+struct MQWrapper
+{
+  /**
+   * State of the command.
+   */
+  struct SendSimplePerfState *sss;
+
+  /**
+   * Message queue for a peer.
+   */
+  struct GNUNET_MQ_Handle *mq;
+
+  /**
+   * Number of messages allready send.
+   */
+  uint32_t num_send;
+};
+
+/**
+ * The cleanup function of this cmd frees resources the cmd allocated.
+ *
+ */
+static void
+send_simple_cleanup (void *cls)
+{
+  struct SendSimpleState *sss = cls;
+
+  GNUNET_free (sss);
+}
+
+
+static void
+send_simple_single (void *cls)
+{
+  struct MQWrapper *mq_wrapper = cls;
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_TRANSPORT_TESTING_PerformanceTestMessage *test;
+  struct GNUNET_TIME_Absolute now;
+
+  now = GNUNET_TIME_absolute_get ();
+  mq_wrapper->num_send++;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Sending simple test message with size %u number %u with mq %p max %u\n",
+       mq_wrapper->sss->size,
+       mq_wrapper->num_send,
+       mq_wrapper->mq,
+       mq_wrapper->sss->max_send);
+
+  env = GNUNET_MQ_msg_extra (test,
+                             mq_wrapper->sss->size - sizeof(*test),
+                             GNUNET_TRANSPORT_TESTING_SIMPLE_PERFORMANCE_MTYPE);
+  test->num = htonl (mq_wrapper->num_send);
+  test->time_send = GNUNET_TIME_absolute_hton (now);
+  memset (&test[1],
+          '1',
+          mq_wrapper->sss->size - sizeof(*test));
+  GNUNET_MQ_send (mq_wrapper->mq,
+                  env);
+  if (mq_wrapper->sss->max_send > mq_wrapper->num_send)
+    GNUNET_SCHEDULER_add_now (&send_simple_single, mq_wrapper);
+  else
+    GNUNET_TESTING_async_finish (&mq_wrapper->sss->ac);
+}
+
+
+static int
+send_simple_cb  (void *cls,
+                 const struct GNUNET_ShortHashCode *key,
+                 void *value)
+{
+  struct SendSimplePerfState *sss = cls;
+  struct GNUNET_MQ_Handle *mq = value;
+  struct MQWrapper *mq_wrapper = GNUNET_new (struct MQWrapper);
+
+  mq_wrapper->sss = sss;
+  mq_wrapper->mq = mq;
+  send_simple_single (mq_wrapper);
+
+  return GNUNET_OK;
+}
+
+
+/**
+ * The run method of this cmd will send a simple message to the connected peers.
+ *
+ */
+static void
+send_simple_run (void *cls,
+                 struct GNUNET_TESTING_Interpreter *is)
+{
+  struct SendSimplePerfState *sss = cls;
+  const struct GNUNET_CONTAINER_MultiShortmap *connected_peers_map;
+  const struct GNUNET_TESTING_Command *peer1_cmd;
+  const struct GNUNET_TESTING_Command *system_cmd;
+  const struct GNUNET_TESTBED_System *tl_system;
+
+
+  peer1_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                         sss->start_peer_label);
+  GNUNET_TRANSPORT_TESTING_get_trait_connected_peers_map (peer1_cmd,
+                                                          &connected_peers_map);
+
+  system_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                          sss->create_label);
+  GNUNET_TESTING_get_trait_test_system (system_cmd,
+                                        &tl_system);
+
+  GNUNET_CONTAINER_multishortmap_iterate (
+    (struct GNUNET_CONTAINER_MultiShortmap *)
+    connected_peers_map, send_simple_cb,
+    sss);
+}
+
+
+struct GNUNET_TESTING_Command
+GNUNET_TRANSPORT_cmd_send_simple_performance (const char *label,
+                                              const char *start_peer_label,
+                                              const char *create_label,
+                                              uint32_t num,
+                                              int size,
+                                              int max_send,
+                                              struct
+                                              GNUNET_TESTING_NetjailTopology *
+                                              topology)
+{
+  struct SendSimplePerfState *sss;
+  struct GNUNET_TESTING_Command cmd;
+
+  sss = GNUNET_new (struct SendSimplePerfState);
+  sss->start_peer_label = start_peer_label;
+  sss->create_label = create_label;
+  sss->topology = topology;
+  sss->size = size;
+  sss->max_send = max_send;
+  cmd = GNUNET_TESTING_command_new_ac (sss,
+                                       label,
+                                       &send_simple_run,
+                                       &send_simple_cleanup,
+                                       NULL,
+                                       &sss->ac);
+  cmd.asynchronous_finish = GNUNET_YES;
+  return cmd;
+}
diff --git a/src/service/transport/transport_api_cmd_start_peer.c b/src/service/transport/transport_api_cmd_start_peer.c
new file mode 100644
index 000000000..862d28b4c
--- /dev/null
+++ b/src/service/transport/transport_api_cmd_start_peer.c
@@ -0,0 +1,484 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testing_api_cmd_start_peer.c
+ * @brief cmd to start a peer.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_ng_lib.h"
+#include "gnunet_testing_netjail_lib.h"
+#include "gnunet_peerstore_service.h"
+#include "gnunet_transport_core_service.h"
+#include "gnunet_transport_application_service.h"
+#include "transport-testing-cmds.h"
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
+
+
+static void
+retrieve_hello (void *cls);
+
+
+/**
+ * Callback delivering the hello of this peer from peerstore.
+ *
+ */
+static void
+hello_iter_cb (void *cb_cls,
+               const struct GNUNET_PEERSTORE_Record *record,
+               const char *emsg)
+{
+  struct GNUNET_TESTING_StartPeerState *sps = cb_cls;
+  if (NULL == record)
+  {
+    sps->pic = NULL;
+    sps->rh_task = GNUNET_SCHEDULER_add_now (retrieve_hello, sps);
+    return;
+  }
+  // Check record type et al?
+  sps->hello_size = record->value_size;
+  sps->hello = GNUNET_malloc (sps->hello_size);
+  memcpy (sps->hello, record->value, sps->hello_size);
+  sps->hello[sps->hello_size - 1] = '\0';
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Our hello %s\n",
+       sps->hello);
+  GNUNET_PEERSTORE_iteration_stop (sps->pic);
+  sps->pic = NULL;
+  GNUNET_TESTING_async_finish (&sps->ac);
+}
+
+
+/**
+ * Function to start the retrieval task to retrieve the hello of this peer
+ * from the peerstore.
+ *
+ */
+static void
+retrieve_hello (void *cls)
+{
+  struct GNUNET_TESTING_StartPeerState *sps = cls;
+  sps->rh_task = NULL;
+  sps->pic = GNUNET_PEERSTORE_iteration_start (sps->ph,
+                                               "transport",
+                                               &sps->id,
+                                               GNUNET_PEERSTORE_TRANSPORT_HELLO_KEY,
+                                               hello_iter_cb,
+                                               sps);
+
+}
+
+
+/**
+ * Disconnect callback for the connection to the core service.
+ *
+ */
+static void
+notify_disconnect (void *cls,
+                   const struct GNUNET_PeerIdentity *peer,
+                   void *handler_cls)
+{
+  struct GNUNET_TESTING_StartPeerState *sps = cls;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Peer %s disconnected from peer %u (`%s')\n",
+       GNUNET_i2s (peer),
+       sps->no,
+       GNUNET_i2s (&sps->id));
+
+}
+
+
+/**
+ * Connect callback for the connection to the core service.
+ *
+ */
+static void *
+notify_connect (void *cls,
+                const struct GNUNET_PeerIdentity *peer,
+                struct GNUNET_MQ_Handle *mq)
+{
+  struct GNUNET_TESTING_StartPeerState *sps = cls;
+  struct GNUNET_ShortHashCode *key = GNUNET_new (struct GNUNET_ShortHashCode);
+  struct GNUNET_HashCode hc;
+  struct GNUNET_CRYPTO_EddsaPublicKey public_key = peer->public_key;
+
+  void *ret = (struct GNUNET_PeerIdentity *) peer;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "This Peer %s \n",
+       GNUNET_i2s (&sps->id));
+
+
+  GNUNET_CRYPTO_hash (&public_key, sizeof(public_key), &hc);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Peer %s connected to peer number %u with mq %p\n",
+       GNUNET_i2s (peer),
+       sps->no,
+       mq);
+
+
+  memcpy (key,
+          &hc,
+          sizeof (*key));
+  GNUNET_CONTAINER_multishortmap_put (sps->connected_peers_map,
+                                      key,
+                                      mq,
+                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+
+  GNUNET_free (key);
+
+  sps->notify_connect (sps->ac.is,
+                       peer);
+
+  return ret;
+}
+
+
+/**
+ * The run method of this cmd will start all services of a peer to test the transport service.
+ *
+ */
+static void
+start_peer_run (void *cls,
+                struct GNUNET_TESTING_Interpreter *is)
+{
+  struct GNUNET_TESTING_StartPeerState *sps = cls;
+  char *emsg = NULL;
+  struct GNUNET_PeerIdentity dummy;
+  const struct GNUNET_TESTING_Command *system_cmd;
+  const struct GNUNET_TESTBED_System *tl_system;
+  char *home;
+  char *transport_unix_path;
+  char *tcp_communicator_unix_path;
+  char *udp_communicator_unix_path;
+  char *bindto;
+  char *bindto_udp;
+
+  if (GNUNET_NO == GNUNET_DISK_file_test (sps->cfgname))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "File not found: `%s'\n",
+         sps->cfgname);
+    GNUNET_TESTING_interpreter_fail (is);
+    return;
+  }
+
+
+  sps->cfg = GNUNET_CONFIGURATION_create ();
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_load (sps->cfg, sps->cfgname));
+
+  GNUNET_asprintf (&home,
+                   "$GNUNET_TMP/test-transport/api-tcp-p%u",
+                   sps->no);
+
+  GNUNET_asprintf (&transport_unix_path,
+                   "$GNUNET_RUNTIME_DIR/tng-p%u.sock",
+                   sps->no);
+
+  GNUNET_asprintf (&tcp_communicator_unix_path,
+                   "$GNUNET_RUNTIME_DIR/tcp-comm-p%u.sock",
+                   sps->no);
+
+  GNUNET_asprintf (&udp_communicator_unix_path,
+                   "$GNUNET_RUNTIME_DIR/tcp-comm-p%u.sock",
+                   sps->no);
+
+  GNUNET_asprintf (&bindto,
+                   "%s:60002",
+                   sps->node_ip);
+
+  GNUNET_asprintf (&bindto_udp,
+                   "2086");
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "node_ip %s\n",
+       bindto);
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "bind_udp %s\n",
+       GNUNET_YES == sps->broadcast ?
+       bindto_udp : bindto);
+
+  GNUNET_CONFIGURATION_set_value_string (sps->cfg, "PATHS", "GNUNET_TEST_HOME",
+                                         home);
+  GNUNET_CONFIGURATION_set_value_string (sps->cfg, "transport", "UNIXPATH",
+                                         transport_unix_path);
+  GNUNET_CONFIGURATION_set_value_string (sps->cfg, "communicator-tcp",
+                                         "BINDTO",
+                                         bindto);
+  GNUNET_CONFIGURATION_set_value_string (sps->cfg, "communicator-udp",
+                                         "BINDTO",
+                                         GNUNET_YES == sps->broadcast ?
+                                         bindto_udp : bindto);
+  GNUNET_CONFIGURATION_set_value_string (sps->cfg, "communicator-tcp",
+                                         "UNIXPATH",
+                                         tcp_communicator_unix_path);
+  GNUNET_CONFIGURATION_set_value_string (sps->cfg, "communicator-udp",
+                                         "UNIXPATH",
+                                         udp_communicator_unix_path);
+
+
+  system_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                          sps->system_label);
+  GNUNET_TESTING_get_trait_test_system (system_cmd,
+                                        &tl_system);
+
+  sps->tl_system = tl_system;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Creating testing library with key number %u\n",
+       sps->no);
+
+  if (GNUNET_SYSERR ==
+      GNUNET_TESTING_configuration_create ((struct
+                                            GNUNET_TESTBED_System *) tl_system,
+                                           sps->cfg))
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Testing library failed to create unique configuration based on `%s'\n",
+         sps->cfgname);
+    GNUNET_CONFIGURATION_destroy (sps->cfg);
+    GNUNET_TESTING_interpreter_fail (is);
+    return;
+  }
+
+  sps->peer = GNUNET_TESTING_peer_configure ((struct
+                                              GNUNET_TESTBED_System *) sps->
+                                             tl_system,
+                                             sps->cfg,
+                                             sps->no,
+                                             NULL,
+                                             &emsg);
+  if (NULL == sps->peer)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Testing library failed to create unique configuration based on `%s': `%s' with key number %u\n",
+         sps->cfgname,
+         emsg,
+         sps->no);
+    GNUNET_free (emsg);
+    GNUNET_TESTING_interpreter_fail (is);
+    return;
+  }
+
+  if (GNUNET_OK != GNUNET_TESTING_peer_start (sps->peer))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Testing library failed to create unique configuration based on `%s'\n",
+         sps->cfgname);
+    GNUNET_free (emsg);
+    GNUNET_TESTING_interpreter_fail (is);
+    return;
+  }
+
+  memset (&dummy,
+          '\0',
+          sizeof(dummy));
+
+  GNUNET_TESTING_peer_get_identity (sps->peer,
+                                    &sps->id);
+
+  if (0 == memcmp (&dummy,
+                   &sps->id,
+                   sizeof(struct GNUNET_PeerIdentity)))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Testing library failed to obtain peer identity for peer %u\n",
+         sps->no);
+    GNUNET_free (emsg);
+    GNUNET_TESTING_interpreter_fail (is);
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Peer %u configured with identity `%s'\n",
+       sps->no,
+       GNUNET_i2s_full (&sps->id));
+
+  sps->th = GNUNET_TRANSPORT_core_connect (sps->cfg,
+                                           NULL,
+                                           sps->handlers,
+                                           sps,
+                                           &notify_connect,
+                                           &notify_disconnect);
+  if (NULL == sps->th)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Failed to connect to transport service for peer `%s': `%s'\n",
+         sps->cfgname,
+         emsg);
+    GNUNET_free (emsg);
+    GNUNET_TESTING_interpreter_fail (is);
+    return;
+  }
+
+  sps->ph = GNUNET_PEERSTORE_connect (sps->cfg);
+  if (NULL == sps->ph)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Failed to connect to peerstore service for peer `%s': `%s'\n",
+         sps->cfgname,
+         emsg);
+    GNUNET_free (emsg);
+    GNUNET_TESTING_interpreter_fail (is);
+    return;
+  }
+
+  sps->ah = GNUNET_TRANSPORT_application_init (sps->cfg);
+  if (NULL == sps->ah)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Failed to initialize the TRANSPORT application suggestion client handle for peer `%s': `%s'\n",
+         sps->cfgname,
+         emsg);
+    GNUNET_free (emsg);
+    GNUNET_TESTING_interpreter_fail (is);
+    return;
+  }
+  sps->rh_task = GNUNET_SCHEDULER_add_now (retrieve_hello, sps);
+  GNUNET_free (home);
+  GNUNET_free (transport_unix_path);
+  GNUNET_free (tcp_communicator_unix_path);
+  GNUNET_free (udp_communicator_unix_path);
+  GNUNET_free (bindto);
+  GNUNET_free (bindto_udp);
+}
+
+
+/**
+ * The cleanup function of this cmd frees resources the cmd allocated.
+ *
+ */
+static void
+start_peer_cleanup (void *cls)
+{
+  struct GNUNET_TESTING_StartPeerState *sps = cls;
+
+  if (NULL != sps->handlers)
+  {
+    GNUNET_free (sps->handlers);
+    sps->handlers = NULL;
+  }
+  // TODO Investigate why this caused problems during shutdown.
+  /*if (NULL != sps->cfg)
+  {
+    GNUNET_CONFIGURATION_destroy (sps->cfg);
+    sps->cfg = NULL;
+    }*/
+  GNUNET_free (sps->cfgname);
+  GNUNET_free (sps->node_ip);
+  GNUNET_free (sps->system_label);
+  GNUNET_free (sps->hello);
+  GNUNET_free (sps->connected_peers_map);
+  GNUNET_free (sps);
+}
+
+
+/**
+ * This function prepares an array with traits.
+ *
+ */
+static int
+start_peer_traits (void *cls,
+                   const void **ret,
+                   const char *trait,
+                   unsigned int index)
+{
+  struct GNUNET_TESTING_StartPeerState *sps = cls;
+  struct GNUNET_TRANSPORT_ApplicationHandle *ah = sps->ah;
+  struct GNUNET_PeerIdentity *id = &sps->id;
+  struct GNUNET_CONTAINER_MultiShortmap *connected_peers_map =
+    sps->connected_peers_map;
+  char *hello = sps->hello;
+  size_t hello_size = sps->hello_size;
+
+
+  struct GNUNET_TESTING_Trait traits[] = {
+    GNUNET_TRANSPORT_TESTING_make_trait_application_handle ((const void *) ah),
+    GNUNET_TRANSPORT_TESTING_make_trait_peer_id ((const void *) id),
+    GNUNET_TRANSPORT_TESTING_make_trait_connected_peers_map ((const
+                                                              void *)
+                                                             connected_peers_map),
+    GNUNET_TRANSPORT_TESTING_make_trait_hello ((const void *) hello),
+    GNUNET_TRANSPORT_TESTING_make_trait_hello_size ((const void *) hello_size),
+    GNUNET_TRANSPORT_TESTING_make_trait_state ((const void *) sps),
+    GNUNET_TRANSPORT_TESTING_make_trait_broadcast ((const
+                                                    void *) &sps->broadcast),
+    GNUNET_TESTING_trait_end ()
+  };
+
+  return GNUNET_TESTING_get_trait (traits,
+                                   ret,
+                                   trait,
+                                   index);
+}
+
+
+struct GNUNET_TESTING_Command
+GNUNET_TRANSPORT_cmd_start_peer (const char *label,
+                                 const char *system_label,
+                                 uint32_t no,
+                                 const char *node_ip,
+                                 struct GNUNET_MQ_MessageHandler *handlers,
+                                 const char *cfgname,
+                                 GNUNET_TRANSPORT_notify_connect_cb
+                                 notify_connect,
+                                 unsigned int broadcast)
+{
+  struct GNUNET_TESTING_StartPeerState *sps;
+  struct GNUNET_CONTAINER_MultiShortmap *connected_peers_map =
+    GNUNET_CONTAINER_multishortmap_create (1,GNUNET_NO);
+  unsigned int i;
+
+  sps = GNUNET_new (struct GNUNET_TESTING_StartPeerState);
+  sps->no = no;
+  sps->system_label = GNUNET_strdup (system_label);
+  sps->connected_peers_map = connected_peers_map;
+  sps->cfgname = GNUNET_strdup (cfgname);
+  sps->node_ip = GNUNET_strdup (node_ip);
+  sps->notify_connect = notify_connect;
+  sps->broadcast = broadcast;
+
+  if (NULL != handlers)
+  {
+    for (i = 0; NULL != handlers[i].cb; i++)
+      ;
+    sps->handlers = GNUNET_new_array (i + 1,
+                                      struct GNUNET_MQ_MessageHandler);
+    GNUNET_memcpy (sps->handlers,
+                   handlers,
+                   i * sizeof(struct GNUNET_MQ_MessageHandler));
+  }
+  return GNUNET_TESTING_command_new_ac (sps,
+                                        label,
+                                        &start_peer_run,
+                                        &start_peer_cleanup,
+                                        &start_peer_traits,
+                                        &sps->ac);
+}
diff --git a/src/service/transport/transport_api_cmd_stop_peer.c b/src/service/transport/transport_api_cmd_stop_peer.c
new file mode 100644
index 000000000..76a30d638
--- /dev/null
+++ b/src/service/transport/transport_api_cmd_stop_peer.c
@@ -0,0 +1,153 @@
+/*
+      This file is part of GNUnet
+      Copyright (C) 2021 GNUnet e.V.
+
+      GNUnet is free software: you can redistribute it and/or modify it
+      under the terms of the GNU Affero General Public License as published
+      by the Free Software Foundation, either version 3 of the License,
+      or (at your option) any later version.
+
+      GNUnet is distributed in the hope that it will be useful, but
+      WITHOUT ANY WARRANTY; without even the implied warranty of
+      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+      Affero General Public License for more details.
+
+      You should have received a copy of the GNU Affero General Public License
+      along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+     SPDX-License-Identifier: AGPL3.0-or-later
+ */
+
+/**
+ * @file testing_api_cmd_stop_peer.c
+ * @brief cmd to stop a peer.
+ * @author t3sserakt
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_ng_lib.h"
+#include "gnunet_testing_netjail_lib.h"
+#include "gnunet_peerstore_service.h"
+#include "gnunet_transport_core_service.h"
+#include "gnunet_transport_application_service.h"
+#include "transport-testing-cmds.h"
+
+/**
+ * Generic logging shortcut
+ */
+#define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__)
+
+
+/**
+ * Struct to hold information for callbacks.
+ *
+ */
+struct StopPeerState
+{
+  // Label of the cmd to start the peer.
+  const char *start_label;
+};
+
+
+/**
+ * The run method of this cmd will stop all services of a peer which were used to test the transport service.
+ *
+ */
+static void
+stop_peer_run (void *cls,
+               struct GNUNET_TESTING_Interpreter *is)
+{
+  struct StopPeerState *stop_ps = cls;
+  const struct GNUNET_TESTING_StartPeerState *sps;
+  const struct GNUNET_TESTING_Command *start_cmd;
+
+  start_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
+                                                         stop_ps->start_label);
+  GNUNET_TRANSPORT_TESTING_get_trait_state (start_cmd,
+                                            &sps);
+
+  if (NULL != sps->pic)
+  {
+    GNUNET_PEERSTORE_iteration_stop (sps->pic);
+  }
+  if (NULL != sps->th)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Disconnecting from TRANSPORT service\n");
+    GNUNET_TRANSPORT_core_disconnect (sps->th);
+  }
+  if (NULL != sps->ah)
+  {
+    GNUNET_TRANSPORT_application_done (sps->ah);
+  }
+  if (NULL != sps->ph)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Disconnecting from PEERSTORE service\n");
+    GNUNET_PEERSTORE_disconnect (sps->ph);
+  }
+  if (NULL != sps->peer)
+  {
+    if (GNUNET_OK !=
+        GNUNET_TESTING_peer_stop (sps->peer))
+    {
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           "Testing lib failed to stop peer %u (`%s')\n",
+           sps->no,
+           GNUNET_i2s (&sps->id));
+    }
+    GNUNET_TESTING_peer_destroy (sps->peer);
+  }
+  if (NULL != sps->rh_task)
+    GNUNET_SCHEDULER_cancel (sps->rh_task);
+}
+
+
+/**
+ * The cleanup function of this cmd frees resources the cmd allocated.
+ *
+ */
+static void
+stop_peer_cleanup (void *cls)
+{
+  struct StopPeerState *sps = cls;
+
+  GNUNET_free (sps);
+}
+
+
+/**
+ * Trait function of this cmd does nothing.
+ *
+ */
+static int
+stop_peer_traits (void *cls,
+                  const void **ret,
+                  const char *trait,
+                  unsigned int index)
+{
+  return GNUNET_OK;
+}
+
+
+/**
+ * Create command.
+ *
+ * @param label name for command.
+ * @param start_label Label of the cmd to start the peer.
+ * @return command.
+ */
+struct GNUNET_TESTING_Command
+GNUNET_TRANSPORT_cmd_stop_peer (const char *label,
+                                const char *start_label)
+{
+  struct StopPeerState *sps;
+
+  sps = GNUNET_new (struct StopPeerState);
+  sps->start_label = start_label;
+  return GNUNET_TESTING_command_new (sps,
+                                     label,
+                                     &stop_peer_run,
+                                     &stop_peer_cleanup,
+                                     &stop_peer_traits);
+}
diff --git a/src/service/transport/upnp.sh b/src/service/transport/upnp.sh
new file mode 100755
index 000000000..d01a1a1a1
--- /dev/null
+++ b/src/service/transport/upnp.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+
+if [ $2 -eq 1 ]
+then
+    if [ ! -d /tmp/netjail_scripts ]
+    then
+        mkdir /tmp/netjail_scripts
+    fi
+
+    ext_ifname=$(ip addr |grep UP|grep "@"|awk -F: '{printf $2"\n"}'|tr  -d " "|awk -F@ '{printf $1" "}'|awk '{printf $1}')
+    listening_ip=$(ip addr |grep UP|grep "@"|awk -F: '{printf $2"\n"}'|tr  -d " "|awk -F@ '{printf $1" "}'|awk '{printf $2}')
+    uuid=$(uuidgen)
+    cat miniupnpd.conf |sed 's/#ext_ifname=eth1/ext_ifname='$ext_ifname'/g'|sed 's/#listening_ip=eth0/listening_ip='$listening_ip'/g'|sed 's/uuid=73a9cb68-a00b-4d2c-8412-75fc989f0c6/uuid='$uuid'/g'|grep -v "^#"|grep -v '^$' > /tmp/netjail_scripts/gargoyle.txt
+    miniupnpd -d -f /tmp/netjail_scripts/gargoyle.txt -P /tmp/netjail_scripts/miniupnpd_$1.pid &
+else
+    kill $(cat /tmp/netjail_scripts/miniupnpd_$1.pid)
+fi
+
+
+
+
+