32 files changed, 2964 insertions, 1154 deletions

diff --git a/src/transport/.gitignore b/src/transport/.gitignore
index 5a82a787b..163ffbd5d 100644
--- a/src/transport/.gitignore
+++ b/src/transport/.gitignore
@@ -87,7 +87,8 @@ gnunet-communicator-unix
 gnunet-service-tng
 gnunet-communicator-tcp
 gnunet-communicator-udp
-test_communicator_unix
-test_communicator_basic_unix
+test_communicator_basic-*
+test_communicator_rekey-*
 test_transport_start_with_config
 test_transport_api2_tcp
+gnunet-communicator-quic
diff --git a/src/transport/Makefile.am b/src/transport/Makefile.am
index 5b51f3edd..d7d25b7b0 100644
--- a/src/transport/Makefile.am
+++ b/src/transport/Makefile.am
@@ -220,7 +220,12 @@ libexec_PROGRAMS = \
  gnunet-communicator-unix \
  gnunet-communicator-udp \
  gnunet-communicator-tcp
-
+if HAVE_EXPERIMENTAL
+if HAVE_QUICHE
+libexec_PROGRAMS += \
+ gnunet-communicator-quic
+endif
+endif
 
 
 bin_PROGRAMS = \
@@ -269,6 +274,22 @@ gnunet_communicator_udp_LDADD = \
   $(top_builddir)/src/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/peerstore/libgnunetpeerstore.la \
+  $(top_builddir)/src/nat/libgnunetnatnew.la \
+  $(top_builddir)/src/nt/libgnunetnt.la \
+  $(top_builddir)/src/statistics/libgnunetstatistics.la \
+  $(top_builddir)/src/util/libgnunetutil.la \
+  -lquiche \
+  $(LIBGCRYPT_LIBS)
+endif
+endif
 
 gnunet_helper_transport_wlan_SOURCES = \
  gnunet-helper-transport-wlan.c
@@ -690,6 +711,7 @@ check_PROGRAMS += \
   test_communicator_basic-unix \
   test_communicator_basic-tcp \
   test_communicator_basic-udp \
+  test_communicator_basic-quic \
   test_communicator_rekey-tcp \
   test_communicator_rekey-udp \
   test_communicator_backchannel-udp \
@@ -768,6 +790,7 @@ TESTS += \
   test_quota_compliance_udp \
   test_communicator_basic-unix \
   test_communicator_basic-tcp \
+  test_communicator_basic-quic \
   test_communicator_basic-udp \
   test_communicator_rekey-tcp \
   test_communicator_rekey-udp \
@@ -934,6 +957,14 @@ test_communicator_basic_udp_LDADD = \
  $(top_builddir)/src/util/libgnunetutil.la \
  $(top_builddir)/src/statistics/libgnunetstatistics.la
 
+test_communicator_basic_quic_SOURCES = \
+ test_communicator_basic.c
+test_communicator_basic_quic_LDADD = \
+ libgnunettransporttesting2.la \
+ $(top_builddir)/src/testing/libgnunettesting.la \
+ $(top_builddir)/src/util/libgnunetutil.la \
+ $(top_builddir)/src/statistics/libgnunetstatistics.la
+
 test_communicator_rekey_tcp_SOURCES = \
  test_communicator_basic.c
 test_communicator_rekey_tcp_LDADD = \
diff --git a/src/transport/gnunet-communicator-quic.c b/src/transport/gnunet-communicator-quic.c
new file mode 100644
index 000000000..1225a3817
--- /dev/null
+++ b/src/transport/gnunet-communicator-quic.c
@@ -0,0 +1,1796 @@
+/*
+     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_nt_lib.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/transport/gnunet-communicator-tcp.c b/src/transport/gnunet-communicator-tcp.c
index e2f1e4507..1273465c3 100644
--- a/src/transport/gnunet-communicator-tcp.c
+++ b/src/transport/gnunet-communicator-tcp.c
@@ -82,9 +82,9 @@
 
 /**
  * How often do we rekey based on number of bytes transmitted?
- * (additionally randomized).
+ * (additionally randomized). Currently 400 MB
  */
-#define REKEY_MAX_BYTES (1024LLU * 1024 * 1024 * 4LLU)
+#define REKEY_MAX_BYTES (1024LLU * 1024 * 400)
 
 /**
  * Size of the initial key exchange message sent first in both
@@ -469,12 +469,6 @@ struct Queue
   struct GNUNET_HashCode out_hmac;
 
   /**
-   * Our ephemeral key. Stored here temporarily during rekeying / key
-   * generation.
-   */
-  struct GNUNET_CRYPTO_EcdhePrivateKey ephemeral;
-
-  /**
    * ID of read task for this connection.
    */
   struct GNUNET_SCHEDULER_Task *read_task;
@@ -667,6 +661,17 @@ struct Queue
    * 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;
 };
 
 
@@ -893,11 +898,6 @@ struct ListenTask *lts_tail;
  */
 int addrs_lens;
 
-/**
- * Size of data received without KX challenge played back.
- */
-// TODO remove?
-size_t unverified_size;
 
 /**
  * Database for peer's HELLOs.
@@ -1357,10 +1357,10 @@ static void
 setup_in_cipher (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral,
                  struct Queue *queue)
 {
-  struct GNUNET_HashCode dh;
+  struct GNUNET_HashCode k;
 
-  GNUNET_CRYPTO_eddsa_ecdh (my_private_key, ephemeral, &dh);
-  setup_cipher (&dh, &my_identity, &queue->in_cipher, &queue->in_hmac);
+  GNUNET_CRYPTO_eddsa_kem_decaps (my_private_key, ephemeral, &k);
+  setup_cipher (&k, &my_identity, &queue->in_cipher, &queue->in_hmac);
 }
 
 
@@ -1557,14 +1557,9 @@ send_challenge (struct GNUNET_CRYPTO_ChallengeNonceP challenge,
  * @param queue queue to setup outgoing (encryption) cipher for
  */
 static void
-setup_out_cipher (struct Queue *queue)
+setup_out_cipher (struct Queue *queue, struct GNUNET_HashCode *dh)
 {
-  struct GNUNET_HashCode dh;
-
-  GNUNET_CRYPTO_ecdh_eddsa (&queue->ephemeral, &queue->target.public_key, &dh);
-  /* we don't need the private key anymore, drop it! */
-  memset (&queue->ephemeral, 0, sizeof(queue->ephemeral));
-  setup_cipher (&dh, &queue->target, &queue->out_cipher, &queue->out_hmac);
+  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);
@@ -1582,13 +1577,14 @@ 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_ecdhe_key_create (&queue->ephemeral);
+  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));
-  GNUNET_CRYPTO_ecdhe_key_get_public (&queue->ephemeral, &rekey.ephemeral);
   rekey.monotonic_time =
     GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg));
   thp.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_COMMUNICATOR_TCP_REKEY);
@@ -1627,9 +1623,10 @@ inject_rekey (struct Queue *queue)
   queue->cwrite_off += sizeof(rekey);
   /* Setup new cipher for successive messages */
   gcry_cipher_close (queue->out_cipher);
-  setup_out_cipher (queue);
+  setup_out_cipher (queue, &k);
 }
 
+
 static int
 pending_reversals_delete_it (void *cls,
                              const struct GNUNET_HashCode *key,
@@ -1829,7 +1826,7 @@ queue_write (void *cls)
   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)&&
+      (((0 == queue->pwrite_off) || ! we_do_not_need_to_rekey) &&
        (queue->cwrite_off + sizeof (struct TCPRekey) <= BUF_SIZE)))
   {
     inject_rekey (queue);
@@ -1868,24 +1865,23 @@ queue_write (void *cls)
 static size_t
 try_handle_plaintext (struct Queue *queue)
 {
-  const struct GNUNET_MessageHeader *hdr =
-    (const struct GNUNET_MessageHeader *) queue->pread_buf;
-  const struct TCPConfirmationAck *tca = (const struct
-                                          TCPConfirmationAck *) queue->pread_buf;
-  const struct TCPBox *box = (const struct TCPBox *) queue->pread_buf;
-  const struct TCPRekey *rekey = (const struct TCPRekey *) queue->pread_buf;
-  const struct TCPFinish *fin = (const struct TCPFinish *) queue->pread_buf;
+  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; /* make compiler happy */
+  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,
@@ -1893,11 +1889,12 @@ try_handle_plaintext (struct Queue *queue)
     return 0; /* not even a header */
   }
 
-  if ((-1 != unverified_size) && (unverified_size > INITIAL_CORE_KX_SIZE))
+  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",
-                unverified_size,
+                queue->unverified_size,
                 INITIAL_CORE_KX_SIZE);
     GNUNET_break_op (0);
     queue_finish (queue);
@@ -1908,6 +1905,7 @@ try_handle_plaintext (struct Queue *queue)
   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)
@@ -1980,7 +1978,11 @@ try_handle_plaintext (struct Queue *queue)
                                          queue->address->sa_family, NULL);
     }
 
-    unverified_size = -1;
+    /**
+     * 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;
 
@@ -2020,6 +2022,7 @@ try_handle_plaintext (struct Queue *queue)
     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);
@@ -2036,6 +2039,7 @@ try_handle_plaintext (struct Queue *queue)
     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))
@@ -2060,6 +2064,7 @@ try_handle_plaintext (struct Queue *queue)
     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))
@@ -2091,8 +2096,8 @@ try_handle_plaintext (struct Queue *queue)
     return 0;
   }
   GNUNET_assert (0 != size);
-  if (-1 != unverified_size)
-    unverified_size += size;
+  if (-1 != queue->unverified_size)
+    queue->unverified_size += size;
   return size;
 }
 
@@ -2712,10 +2717,10 @@ static void
 start_initial_kx_out (struct Queue *queue)
 {
   struct GNUNET_CRYPTO_EcdhePublicKey epub;
+  struct GNUNET_HashCode k;
 
-  GNUNET_CRYPTO_ecdhe_key_create (&queue->ephemeral);
-  GNUNET_CRYPTO_ecdhe_key_get_public (&queue->ephemeral, &epub);
-  setup_out_cipher (queue);
+  GNUNET_CRYPTO_eddsa_kem_encaps (&queue->target.public_key, &epub, &k);
+  setup_out_cipher (queue, &k);
   transmit_kx (queue, &epub);
 }
 
@@ -3060,6 +3065,7 @@ proto_read_kx (void *cls)
   GNUNET_free (pq);
 }
 
+
 static struct ProtoQueue *
 create_proto_queue (struct GNUNET_NETWORK_Handle *sock,
                     struct sockaddr *in,
@@ -3120,7 +3126,6 @@ listen_cb (void *cls)
   struct sockaddr_storage in;
   socklen_t addrlen;
   struct GNUNET_NETWORK_Handle *sock;
-  struct ProtoQueue *pq;
   struct ListenTask *lt;
   struct sockaddr *in_addr;
 
diff --git a/src/transport/gnunet-communicator-udp.c b/src/transport/gnunet-communicator-udp.c
index 4657a7220..a58423c95 100644
--- a/src/transport/gnunet-communicator-udp.c
+++ b/src/transport/gnunet-communicator-udp.c
@@ -11,7 +11,7 @@
      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/>.
 
@@ -38,6 +38,7 @@
  * - 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"
@@ -67,7 +68,7 @@
  * How often do we scan for changes to our network interfaces?
  */
 #define INTERFACE_SCAN_FREQUENCY \
-        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
 
 /**
  * How long do we believe our addresses to remain up (before
@@ -76,7 +77,7 @@
 #define ADDRESS_VALIDITY_PERIOD GNUNET_TIME_UNIT_HOURS
 
 #define WORKING_QUEUE_INTERVALL \
-        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS,1)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS,1)
 
 /**
  * AES key size.
@@ -93,7 +94,7 @@
  */
 #define GCM_TAG_SIZE (128 / 8)
 
-#define GENERATE_AT_ONCE 2
+#define GENERATE_AT_ONCE 16
 
 /**
  * If we fall below this number of available KCNs,
@@ -104,7 +105,7 @@
  * arrive before the sender runs out. So really this
  * should ideally be based on the RTT.
  */
-#define KCN_THRESHOLD 92
+#define KCN_THRESHOLD 96
 
 /**
  * How many KCNs do we keep around *after* we hit
@@ -134,7 +135,7 @@
  * sense. Might make sense to adapt to RTT if we had
  * a good measurement...
  */
-#define MAX_SECRETS 128000
+#define MAX_SECRETS 256
 
 /**
  * Default value for how often we do rekey based on number of bytes transmitted?
@@ -206,12 +207,8 @@ struct InitialKX
    * HMAC for the following encrypted message, using GCM.  HMAC uses
    * key derived from the handshake with sequence number zero.
    */
-  char gcm_tag[GCM_TAG_SIZE];
+  uint8_t gcm_tag[GCM_TAG_SIZE];
 
-  /**
-   * A flag indicating, if the sender is doing rekeying.
-   */
-  int rekeying;
 };
 
 
@@ -258,13 +255,7 @@ struct UDPAck
    * Sequence acknowledgement limit. Specifies current maximum sequence
    * number supported by receiver.
    */
-  uint32_t sequence_max GNUNET_PACKED;
-
-  /**
-   * Sequence acknowledgement limit. Specifies current maximum sequence
-   * number supported by receiver.
-   */
-  uint32_t acks_available GNUNET_PACKED;
+  uint32_t sequence_ack GNUNET_PACKED;
 
   /**
    * CMAC of the base key being acknowledged.
@@ -343,42 +334,24 @@ struct UDPBox
    * wrong, the receiver should check if the message might be a
    * `struct UdpHandshakeSignature`.
    */
-  char gcm_tag[GCM_TAG_SIZE];
+  uint8_t gcm_tag[GCM_TAG_SIZE];
 
-  /**
-   * A flag indicating, if the sender is doing rekeying.
-   */
-  int rekeying;
 };
 
 /**
- * UDP message box.  Always sent encrypted, only allowed after
- * the receiver sent a `struct UDPAck` for the base key!
+ * Plaintext of a rekey payload in a UDPBox.
  */
 struct UDPRekey
 {
   /**
-   * 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`.
+   * Type is #GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_REKEY.
    */
-  char gcm_tag[GCM_TAG_SIZE];
+  struct GNUNET_MessageHeader header;
 
   /**
-   * Sender's identity
+   * Ephemeral key to rekey with.
    */
-  struct GNUNET_PeerIdentity sender;
+  struct GNUNET_CRYPTO_EcdhePublicKey ephemeral;
 };
 
 GNUNET_NETWORK_STRUCT_END
@@ -500,6 +473,21 @@ struct SharedSecret
    * 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;
 };
 
 
@@ -510,16 +498,6 @@ struct SharedSecret
 struct SenderAddress
 {
   /**
-   * Shared secret we use with @e target for rekeying.
-   */
-  struct SharedSecret *ss_rekey;
-
-  /**
-   * Flag indicating sender is initiated rekeying for this receiver.
-   */
-  int rekeying;
-
-  /**
    * To whom are we talking to.
    */
   struct GNUNET_PeerIdentity target;
@@ -575,21 +553,20 @@ struct SenderAddress
    */
   int sender_destroy_called;
 
-
   /**
    * ID of kce working queue task
    */
   struct GNUNET_SCHEDULER_Task *kce_task;
 
   /**
-   * ID of kce rekey working queue task
+   * Is the kce_task finished?
    */
-  struct GNUNET_SCHEDULER_Task *kce_task_rekey;
+  int kce_task_finished;
 
   /**
-   * Is the kce_task finished?
+   * When KCE finishes, send ACK if GNUNET_YES
    */
-  int kce_task_finished;
+  int kce_send_ack_on_finish;
 };
 
 
@@ -599,38 +576,12 @@ struct SenderAddress
  */
 struct ReceiverAddress
 {
-
-  /**
-   * Shared secret we use with @e target for rekeying.
-   */
-  struct SharedSecret *ss_rekey;
-
-  /**
-   * Acks available when we started rekeying.
-   */
-  unsigned int rekey_acks_available;
-
-  /**
-   * Send bytes for this receiver address.
-   */
-  uint64_t rekey_send_bytes;
-
   /**
   * Timeout for this receiver address.
   */
   struct GNUNET_TIME_Absolute rekey_timeout;
 
   /**
-   * Flag indicating sender is initiated rekeying for this receiver.
-   */
-  int rekeying;
-
-  /**
-   * Number of kce we retain for sending the rekeying shared secret.
-   */
-  int number_rekeying_kce;
-
-  /**
    * To whom are we talking to.
    */
   struct GNUNET_PeerIdentity target;
@@ -784,10 +735,6 @@ 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;
-/**
- * Shared secret we finished the last kce working queue for.
- */
-struct SharedSecret *ss_finished;
 
 /**
  * Cache of pre-generated key IDs.
@@ -1050,35 +997,37 @@ kce_generate (struct SharedSecret *ss, uint32_t seq)
  * @param withoutKce If GNUNET_YES shared secrets with kce will not be destroyed.
  */
 static int
-secret_destroy (struct SharedSecret *ss, int withoutKce)
+secret_destroy (struct SharedSecret *ss)
 {
   struct SenderAddress *sender;
   struct ReceiverAddress *receiver;
   struct KeyCacheEntry *kce;
 
-  if (withoutKce && (ss->sequence_allowed > 0))
-    return GNUNET_NO;
-
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "secret %s destroy %u %u\n",
+              "secret %s destroy %u\n",
               GNUNET_h2s (&ss->master),
-              withoutKce,
               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\n",
+                receiver->num_secrets);
+    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--;
-    // Uncomment this for alternativ 1 of backchannel functionality
     receiver->acks_available -= (ss->sequence_allowed - ss->sequence_used);
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "%u receiver->acks_available 3\n",
-                receiver->acks_available);
-    // Until here for alternativ 1
+                "%u receiver->num_secrets\n",
+                receiver->num_secrets);
   }
   while (NULL != (kce = ss->kce_head))
     kce_destroy (kce);
@@ -1337,7 +1286,7 @@ setup_cipher (const struct GNUNET_HashCode *msec,
  */
 static int
 try_decrypt (const struct SharedSecret *ss,
-             const char tag[GCM_TAG_SIZE],
+             const uint8_t *tag,
              uint32_t serial,
              const char *in_buf,
              size_t in_buf_size,
@@ -1375,28 +1324,29 @@ setup_shared_secret_dec (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral)
   struct SharedSecret *ss;
 
   ss = GNUNET_new (struct SharedSecret);
-  GNUNET_CRYPTO_eddsa_ecdh (my_private_key, ephemeral, &ss->master);
+  GNUNET_CRYPTO_eddsa_kem_decaps (my_private_key, ephemeral, &ss->master);
+  calculate_cmac (ss);
   return ss;
 }
 
 
 /**
- * Setup shared secret for encryption.
+ * Setup new shared secret for encryption using KEM.
  *
- * @param ephemeral ephemeral key we are sending to the other peer
+ * @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_enc (const struct GNUNET_CRYPTO_EcdhePrivateKey *ephemeral,
-                         struct ReceiverAddress *receiver, int add_to_receiver)
+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);
-  GNUNET_CRYPTO_ecdh_eddsa (ephemeral,
-                            &receiver->target.public_key,
-                            &ss->master);
+  memcpy (&ss->master, &k, sizeof (k));
   calculate_cmac (ss);
   ss->receiver = receiver;
   GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss);
@@ -1416,60 +1366,39 @@ setup_shared_secret_enc (const struct GNUNET_CRYPTO_EcdhePrivateKey *ephemeral,
 static void
 setup_receiver_mq (struct ReceiverAddress *receiver);
 
+
 /**
- * Destroying all secrets. Depending on parameter we keep those secrets having a kce.
+ * Best effort try to purge some secrets.
+ * Ideally those, not ACKed.
  *
- * @param ss The secret we will not destroy.
- * @param withoutKce If GNUNET_YES shared secrets with kce will not be destroyed.
+ * @param ss_list_tail the oldest secret in the list of interest.
+ * @return number of deleted secrets.
  */
-static void
-destroy_all_secrets (struct SharedSecret *ss, int withoutKce)
+unsigned int
+purge_secrets (struct SharedSecret *ss_list_tail)
 {
-  struct SenderAddress *sender;
-  struct ReceiverAddress *receiver;
-  struct SharedSecret *ss_to_destroy;
-  struct SharedSecret *ss_start;
   struct SharedSecret *pos;
-  int at_least_one_destroyed = GNUNET_NO;
+  struct SharedSecret *ss_to_purge;
+  unsigned int deleted = 0;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting destroy all withoutKce: %u.\n",
-              withoutKce);
-
-  if (NULL != (sender = ss->sender))
-  {
-    ss_start = sender->ss_head;
-  }
-  else if (NULL != (receiver = ss->receiver))
-  {
-    ss_start = receiver->ss_head;
-  }
-  else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Shared secret has no sender or receiver!\n");
-    return;
-  }
-
-  pos = ss_start;
+              "Purging secrets.\n");
+  pos = ss_list_tail;
   while (NULL != pos)
   {
-    ss_to_destroy = pos;
-    pos = pos->next;
-
-    if (ss != ss_to_destroy)
-      at_least_one_destroyed = secret_destroy (ss_to_destroy, withoutKce);
-  }
+    ss_to_purge = pos;
+    pos = pos->prev;
 
-  if ((ss != ss_start) && ! at_least_one_destroyed)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Really destroying all.\n");
-    destroy_all_secrets (ss_start, GNUNET_NO);
+    // 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 destroy all.\n");
+              "Finished purging all, deleted %u.\n", deleted);
+  return deleted;
 }
 
 
@@ -1506,9 +1435,6 @@ add_acks (struct SharedSecret *ss, int acks_to_add)
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Tell transport we have %u more acks!\n",
               acks_to_add);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%u kce for rekeying.\n",
-              receiver->number_rekeying_kce);
 
   // Until here for alternativ 1
 
@@ -1516,63 +1442,6 @@ add_acks (struct SharedSecret *ss, int acks_to_add)
 
   GNUNET_CONTAINER_DLL_remove (receiver->ss_head, receiver->ss_tail, ss);
   GNUNET_CONTAINER_DLL_insert (receiver->ss_head, receiver->ss_tail, ss);
-  destroy_all_secrets (ss, GNUNET_YES);
-}
-
-
-static uint32_t
-reset_rekey_kces (struct ReceiverAddress *receiver,
-                  uint32_t acks_to_add)
-{
-  int needed_for_rekeying;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%u kce for rekeying and %u acks_to_add\n",
-              receiver->number_rekeying_kce,
-              acks_to_add);
-
-  needed_for_rekeying = (3 - receiver->number_rekeying_kce);
-  if (acks_to_add <= needed_for_rekeying)
-  {
-    receiver->number_rekeying_kce += acks_to_add;
-    acks_to_add = 0;
-  }
-  else
-  {
-    acks_to_add -= (3 - receiver->number_rekeying_kce);
-    receiver->number_rekeying_kce = 3;
-  }
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%u kce for rekeying and %u acks_to_add\n",
-              receiver->number_rekeying_kce,
-              acks_to_add);
-  return acks_to_add;
-}
-
-
-static void
-add_acks_rekey (struct ReceiverAddress *receiver)
-{
-  uint32_t acks_to_add = receiver->ss_rekey->sequence_allowed;
-
-  if (receiver->number_rekeying_kce < 3)
-    acks_to_add = reset_rekey_kces (receiver, acks_to_add);
-  receiver->acks_available = receiver->ss_rekey->sequence_allowed;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "%u receiver->acks_available 4\n",
-              receiver->acks_available);
-  if (0 != acks_to_add)
-  {
-    add_acks (receiver->ss_rekey, acks_to_add);
-  }
-  receiver->ss_rekey = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "# rekeying successful\n");
-  GNUNET_STATISTICS_update (stats,
-                            "# rekeying successful",
-                            1,
-                            GNUNET_NO);
 }
 
 
@@ -1598,36 +1467,6 @@ handle_ack (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
               "in handle ack with cmac %s\n",
               GNUNET_h2s (&ack->cmac));
 
-  if (NULL != receiver->ss_rekey)
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "We have rekey secret with cmac %s \n",
-                GNUNET_h2s (&receiver->ss_rekey->cmac));
-
-  if ((NULL != receiver->ss_rekey) && (0 == memcmp (&ack->cmac,
-                                                    &receiver->ss_rekey->cmac,
-                                                    sizeof(struct
-                                                           GNUNET_HashCode))) )
-  {
-    allowed = ntohl (ack->sequence_max);
-
-    if (allowed > receiver->ss_rekey->sequence_allowed)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "%u > %u (%u %u) for rekey secrect %s\n", allowed,
-                  receiver->ss_rekey->sequence_allowed,
-                  receiver->acks_available,
-                  ack->acks_available,
-                  GNUNET_h2s (&receiver->ss_rekey->master));
-
-      receiver->ss_rekey->sequence_allowed = allowed;
-
-      if (GNUNET_NO == receiver->rekeying)
-        add_acks_rekey (receiver);
-
-      return GNUNET_NO;
-    }
-  }
-
   (void) pid;
   for (struct SharedSecret *ss = receiver->ss_head; NULL != ss; ss = ss->next)
   {
@@ -1635,90 +1474,76 @@ handle_ack (void *cls, const struct GNUNET_PeerIdentity *pid, void *value)
     {
 
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Found matching mac\n");
+                  "Found matching cmac\n");
 
-      allowed = ntohl (ack->sequence_max);
+      allowed = ntohl (ack->sequence_ack);
 
-      if (allowed > ss->sequence_allowed)
+      if (allowed <= ss->sequence_allowed)
       {
         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "%u > %u (%u %u) for secrect %s\n", allowed,
-                    ss->sequence_allowed,
-                    receiver->acks_available,
-                    ack->acks_available,
-                    GNUNET_h2s (&ss->master));
-        acks_to_add = (allowed - ss->sequence_allowed);
-        if ((GNUNET_NO == receiver->rekeying) &&
-            (receiver->number_rekeying_kce < 3) )
-          acks_to_add = reset_rekey_kces (receiver, acks_to_add);
-
-        if ((0 != acks_to_add) && (GNUNET_NO == receiver->rekeying))
-        {
-          receiver->acks_available += (allowed - ss->sequence_allowed);
-          ss->sequence_allowed = allowed;
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "%u receiver->acks_available 5\n",
-                      receiver->acks_available);
-          add_acks (ss, acks_to_add);
-        }
+                    "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;
 }
 
 
 /**
- * Test if we have received a valid message in plaintext.
- * If so, handle it.
+ * 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 sender peer to process inbound plaintext for
- * @param buf buffer we received
- * @param buf_size number of bytes in @a buf
+ * @param ss shared secret to generate ACKs for
  */
 static void
-try_handle_plaintext (struct SenderAddress *sender,
-                      const void *buf,
-                      size_t buf_size)
+consider_ss_ack (struct SharedSecret *ss)
 {
-  const struct GNUNET_MessageHeader *hdr =
-    (const struct GNUNET_MessageHeader *) buf;
-  const struct UDPAck *ack = (const struct UDPAck *) buf;
-  uint16_t type;
+  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,
-              "try_handle_plaintext of size %lu (%u %lu) and type %u\n",
-              buf_size,
-              ntohs (hdr->size),
-              sizeof(*hdr),
-              ntohs (hdr->type));
-  if (sizeof(*hdr) > buf_size)
-    return; /* not even a header */
-  if (ntohs (hdr->size) > buf_size)
-    return; /* not even a header */
-  type = ntohs (hdr->type);
-  switch (type)
-  {
-  case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK:
-    /* lookup master secret by 'cmac', then update sequence_max */
-    GNUNET_CONTAINER_multipeermap_get_multiple (receivers,
-                                                &sender->target,
-                                                &handle_ack,
-                                                (void *) ack);
-    /* There could be more messages after the ACK, handle those as well */
-    buf += ntohs (hdr->size);
-    buf_size -= ntohs (hdr->size);
-    pass_plaintext_to_core (sender, buf, buf_size);
-    break;
+              "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);
 
-  case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD:
-    /* skip padding */
-    break;
 
-  default:
-    pass_plaintext_to_core (sender, buf, buf_size);
-  }
+  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);
 }
 
 
@@ -1726,173 +1551,139 @@ static void
 kce_generate_cb (void *cls)
 {
   struct SharedSecret *ss = cls;
-
   ss->sender->kce_task = NULL;
 
-  if (((GNUNET_NO == ss->sender->rekeying) && (ss->sender->acks_available <
-                                               KCN_TARGET) ) ||
-      ((ss->sender->ss_rekey == ss) && (GNUNET_YES == ss->sender->rekeying) &&
-       (ss->sender->acks_available < KCN_TARGET)))
-  {
-
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Precomputing keys for master %s\n",
-                GNUNET_h2s (&(ss->master)));
-
-    for (int i = 0; i < GENERATE_AT_ONCE; i++)
-      kce_generate (ss, ++ss->sequence_allowed);
-
-    if (KCN_TARGET > ss->sender->acks_available)
-    {
-      ss->sender->kce_task = GNUNET_SCHEDULER_add_delayed (
-        WORKING_QUEUE_INTERVALL,
-        kce_generate_cb,
-        ss);
-    }
-    else
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "We have enough keys.\n");
-      ss_finished = ss;
-      ss->sender->kce_task_finished = GNUNET_YES;
-    }
-  }
-
-
-}
-
-
-static void
-kce_generate_rekey_cb (void *cls)
-{
-  struct SharedSecret *ss = cls;
-
-  ss->sender->kce_task_rekey = 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);
 
-  if (NULL == ss->sender->kce_task)
+  /**
+   * 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)
   {
-
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Precomputing keys for rekey master %s\n",
-                GNUNET_h2s (&(ss->master)));
-
-    for (int i = 0; i < GENERATE_AT_ONCE; i++)
-      kce_generate (ss, ++ss->sequence_allowed);
-
     ss->sender->kce_task = GNUNET_SCHEDULER_add_delayed (
       WORKING_QUEUE_INTERVALL,
       kce_generate_cb,
       ss);
-    ss->sender->kce_task_rekey = NULL;
-  }
-  else
-  {
-    ss->sender->kce_task_rekey = GNUNET_SCHEDULER_add_delayed (
-      WORKING_QUEUE_INTERVALL,
-      kce_generate_rekey_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);
 }
 
 
 /**
- * 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).
+ * Test if we have received a valid message in plaintext.
+ * If so, handle it.
  *
- * @param ss shared secret to generate ACKs for
- * @param initial The SharedSecret came with initial KX.
+ * @param sender peer to process inbound plaintext for
+ * @param buf buffer we received
+ * @param buf_size number of bytes in @a buf
  */
 static void
-consider_ss_ack (struct SharedSecret *ss, int initial)
+try_handle_plaintext (struct SenderAddress *sender,
+                      const void *buf,
+                      size_t buf_size)
 {
-  struct GNUNET_SCHEDULER_Task *kce_task_rekey;
-  struct GNUNET_SCHEDULER_Task *kce_task;
-  int kce_task_finished;
-
-  kce_task_rekey = ss->sender->kce_task_rekey;
-  kce_task_finished = ss->sender->kce_task_finished;
-  kce_task = ss->sender->kce_task;
-
-  GNUNET_assert (NULL != ss->sender);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Considering SS UDPAck %s\n",
-              GNUNET_i2s_full (&ss->sender->target));
+  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,
-              "We have %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);
-
-
-  if (GNUNET_NO == initial)
-    kce_generate (ss, ++ss->sequence_allowed);
-
-  if (NULL != kce_task)
+              "try_handle_plaintext of size %lu (%u %lu) and type %u\n",
+              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_ERROR,
+                "Received rekey secret with cmac %s\n",
+                GNUNET_h2s (&(ss_rekey->cmac)));
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "kce_task is not NULL\n");
-  if (kce_task_finished)
+                "Received secret with master %s.\n",
+                GNUNET_h2s (&(ss_rekey->master)));
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "kce_task_finished: GNUNET_YES\n");
-  if (initial)
+                "We have %u sequence_allowed.\n",
+                ss_rekey->sequence_allowed);
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "initial: GNUNET_YES\n");
-
-  if (kce_task_finished || (GNUNET_NO == initial))
-  {
-    struct UDPAck ack;
-    struct SharedSecret *ss_tell;
-
-    if (GNUNET_NO != initial)
-      ss_tell = ss_finished;
-    else
-      ss_tell = ss;
-
-    ack.header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK);
-    ack.header.size = htons (sizeof(ack));
-    ack.sequence_max = htonl (ss_tell->sequence_allowed);
-    ack.acks_available = ss->sender->acks_available;
-    ack.cmac = ss_tell->cmac;
+                "We have a sender %p\n",
+                ss_rekey->sender);
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Notifying transport of UDPAck %s with initial %u and master %s\n",
-                GNUNET_i2s_full (&ss_tell->sender->target),
-                initial,
-                GNUNET_h2s (&(ss_tell->master)));
-    GNUNET_TRANSPORT_communicator_notify (ch,
-                                          &ss_tell->sender->target,
-                                          COMMUNICATOR_ADDRESS_PREFIX,
-                                          &ack.header);
-    if (GNUNET_NO != initial)
+                "We have %u acks available.\n",
+                ss_rekey->sender->acks_available);
+    ss_rekey->sender->kce_send_ack_on_finish = GNUNET_YES;
+    ss_rekey->override_available_acks = GNUNET_YES;
+    // FIXME
+    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 (sender->num_secrets > MAX_SECRETS)
     {
-      destroy_all_secrets (ss, GNUNET_YES);
-      ss->sender->kce_task_finished = GNUNET_NO;
+      if (0 == purge_secrets (sender->ss_tail))
+      {
+        // No secret purged. Delete oldest.
+        secret_destroy (sender->ss_tail);
+      }
     }
-  }
-  else if ((NULL == kce_task) && ((KCN_THRESHOLD >
-                                   ss->sender->acks_available) ||
-                                  (GNUNET_YES == ss->sender->rekeying) ||
-                                  (ss->sender->num_secrets > MAX_SECRETS) ))
-  {
+    break;
+  case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_ACK:
+    /* lookup master secret by 'cmac', then update sequence_max */
+    ack = (struct UDPAck*) buf_pos;
+    GNUNET_CONTAINER_multipeermap_get_multiple (receivers,
+                                                &sender->target,
+                                                &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;
 
-    // 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.
-    kce_task = GNUNET_SCHEDULER_add_delayed (WORKING_QUEUE_INTERVALL,
-                                             kce_generate_cb,
-                                             ss);
-    kce_task_finished = GNUNET_NO;
+  case GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_PAD:
+    /* skip padding */
+    break;
 
+  default:
+    pass_plaintext_to_core (sender, buf_pos, bytes_remaining);
   }
-  else if ((NULL == kce_task_rekey) && (GNUNET_YES ==
-                                        ss->sender->rekeying) )
-  {
-    kce_task_rekey = GNUNET_SCHEDULER_add_delayed (WORKING_QUEUE_INTERVALL,
-                                                   kce_generate_rekey_cb,
-                                                   ss);
-  }
+  return;
 }
 
 
@@ -1919,6 +1710,7 @@ decrypt_box (const struct UDPBox *box,
                                 sizeof(out_buf),
                                 out_buf))
   {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed decryption.\n");
     GNUNET_STATISTICS_update (stats,
                               "# Decryption failures with valid KCE",
                               1,
@@ -1927,6 +1719,7 @@ decrypt_box (const struct UDPBox *box,
     return;
   }
   kce_destroy (kce);
+  kce = NULL;
   GNUNET_STATISTICS_update (stats,
                             "# bytes decrypted with BOX",
                             sizeof(out_buf),
@@ -1939,95 +1732,18 @@ decrypt_box (const struct UDPBox *box,
               "decrypted UDPBox with kid %s\n",
               GNUNET_sh2s (&box->kid));
   try_handle_plaintext (ss->sender, out_buf, sizeof(out_buf));
-  if ((GNUNET_NO == box->rekeying) && (GNUNET_YES == ss->sender->rekeying))
-  {
-    ss->sender->rekeying = GNUNET_NO;
-    ss->sender->ss_rekey = NULL;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Receiver stopped rekeying.\n");
-  }
-  else
-  {
-    ss->sender->rekeying = GNUNET_YES;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Got Box: Receiver doing rekeying.\n");
-  }
-}
-
-
-/**
- * We received a @a rekey with matching @a kce.  Decrypt and process it.
- *
- * @param rekey the data we received
- * @param rekey_len number of bytes in @a rekey
- * @param kce key index to decrypt @a rekey
- */
-static void
-decrypt_rekey (const struct UDPRekey *rekey,
-               size_t rekey_len,
-               struct KeyCacheEntry *kce,
-               struct SenderAddress *sender)
-{
-  struct SharedSecret *ss = kce->ss;
-  struct SharedSecret *ss_rekey;
-  char out_buf[rekey_len - sizeof(*rekey)];
-  struct GNUNET_HashCode *master;
-
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "decrypt_rekey.\n");
-
-  GNUNET_assert (NULL != ss->sender);
-  if (GNUNET_OK != try_decrypt (ss,
-                                rekey->gcm_tag,
-                                kce->sequence_number,
-                                (const char *) &rekey[1],
-                                sizeof(out_buf),
-                                out_buf))
+  if ((KCN_THRESHOLD > ss->sender->acks_available) &&
+      (NULL == ss->sender->kce_task) &&
+      (GNUNET_YES == ss->sender->kce_task_finished))
   {
-    GNUNET_STATISTICS_update (stats,
-                              "# Decryption failures with valid KCE",
-                              1,
-                              GNUNET_NO);
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Decryption with kid %s failed\n",
-                GNUNET_sh2s (&rekey->kid));
-    kce_destroy (kce);
-    return;
+                "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);
   }
-  kce_destroy (kce);
-  GNUNET_STATISTICS_update (stats,
-                            "# bytes decrypted with Rekey",
-                            sizeof(out_buf),
-                            GNUNET_NO);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "decrypted UDPRekey with kid %s\n",
-              GNUNET_sh2s (&rekey->kid));
-  master = (struct GNUNET_HashCode *) out_buf;
-  ss_rekey = GNUNET_new (struct SharedSecret);
-  ss_rekey->master = *master;
-  calculate_cmac (ss_rekey);
-  ss_rekey->sender = sender;
-  GNUNET_CONTAINER_DLL_insert (sender->ss_head, sender->ss_tail, ss_rekey);
-  sender->ss_rekey = ss_rekey;
-  sender->num_secrets++;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received 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);
-  consider_ss_ack (ss_rekey, GNUNET_YES);
-
 }
 
 
@@ -2218,222 +1934,196 @@ sock_read (void *cls)
                                              udp_sock,
                                              &sock_read,
                                              NULL);
-  rcvd = GNUNET_NETWORK_socket_recvfrom (udp_sock,
-                                         buf,
-                                         sizeof(buf),
-                                         (struct sockaddr *) &sa,
-                                         &salen);
-  if (-1 == rcvd)
-  {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "recv");
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Read %lu bytes\n", rcvd);
-
-  if (rcvd > sizeof(struct UDPRekey))
-  {
-    const struct UDPRekey *rekey;
-    const struct UDPBox *box;
-    struct KeyCacheEntry *kce;
-    struct SenderAddress *sender;
-    int do_decrypt = GNUNET_NO;
-
-    rekey = (const struct UDPRekey *) buf;
-    box = (const struct UDPBox *) buf;
-    kce = GNUNET_CONTAINER_multishortmap_get (key_cache, &rekey->kid);
-
-    if ((GNUNET_YES == box->rekeying) || (GNUNET_NO == box->rekeying))
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "UDPRekey has rekeying %u\n",
-                  box->rekeying);
-    else
-      do_decrypt = GNUNET_YES;
-
-    if ((GNUNET_YES == do_decrypt) && (NULL != kce) && (GNUNET_YES ==
-                                                        kce->ss->sender->
-                                                        rekeying))
+  while (1)
+  {
+    rcvd = GNUNET_NETWORK_socket_recvfrom (udp_sock,
+                                           buf,
+                                           sizeof(buf),
+                                           (struct sockaddr *) &sa,
+                                           &salen);
+    if (-1 == rcvd)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "UDPRekey with kid %s\n",
-                  GNUNET_sh2s (&rekey->kid));
-      sender = setup_sender (&rekey->sender, (const struct sockaddr *) &sa,
-                             salen);
-
-      if (NULL != sender->ss_rekey)
-        return;
-
-      decrypt_rekey (rekey, (size_t) rcvd, kce, sender);
+      if (EAGAIN == errno)
+        break; // We are done reading data
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "recv");
       return;
     }
-  }
-
-  /* first, see if it is a UDPBox */
-  if (rcvd > sizeof(struct UDPBox))
-  {
-    const struct UDPBox *box;
-    struct KeyCacheEntry *kce;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Read %lu bytes\n", rcvd);
 
-    box = (const struct UDPBox *) buf;
-    kce = GNUNET_CONTAINER_multishortmap_get (key_cache, &box->kid);
-    if (NULL != kce)
+    /* first, see if it is a UDPBox */
+    if (rcvd > sizeof(struct UDPBox))
     {
-      decrypt_box (box, (size_t) rcvd, kce);
-      return;
-    }
-  }
+      const struct UDPBox *box;
+      struct KeyCacheEntry *kce;
 
-  /* next, check if it is a broadcast */
-  if (sizeof(struct UDPBroadcast) == rcvd)
-  {
-    const struct UDPBroadcast *ub;
-    struct UdpBroadcastSignature uhs;
-    struct GNUNET_PeerIdentity sender;
+      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;
+      }
+    }
 
-    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)))
+    /* 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 our own broadcast\n");
-      GNUNET_free (addr_verify);
-      return;
-    }
-    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);
+                  "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,
-                  "validating address %s received from UDPBroadcast\n",
+                  "checking UDPBroadcastSignature for %s\n",
                   GNUNET_i2s (&sender));
-      GNUNET_TRANSPORT_application_validate (ah, &sender, nt, addr_s);
-      GNUNET_free (addr_s);
+      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);
-      return;
+      /* continue with KX, mostly for statistics... */
     }
-    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);
-    return;
-  }
-  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_shared_secret_dec (&kx->ephemeral);
-    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);
-      return;
-    }
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Before VERIFY\n");
 
-    uc = (const struct UDPConfirmation *) pbuf;
-    if (GNUNET_OK != verify_confirmation (&kx->ephemeral, uc))
+    /* finally, test if it is a KX */
+    if (rcvd < sizeof(struct UDPConfirmation) + sizeof(struct InitialKX))
     {
-      GNUNET_break_op (0);
-      GNUNET_free (ss);
       GNUNET_STATISTICS_update (stats,
-                                "# messages dropped (sender signature invalid)",
+                                "# messages dropped (no kid, too small for KX)",
                                 1,
                                 GNUNET_NO);
-      return;
+      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);
-    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 ((GNUNET_NO == kx->rekeying) && (GNUNET_YES == ss->sender->rekeying))
+                "Got KX\n");
     {
-      ss->sender->rekeying = GNUNET_NO;
-      sender->ss_rekey = NULL;
-      // destroy_all_secrets (ss, GNUNET_NO);
+      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_shared_secret_dec (&kx->ephemeral);
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Receiver stopped rekeying.\n");
-    }
-    else if (GNUNET_NO == kx->rekeying)
-      consider_ss_ack (ss, GNUNET_YES);
-    else
-    {
-      ss->sender->rekeying = GNUNET_YES;
+                  "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;
+      if (GNUNET_OK != verify_confirmation (&kx->ephemeral, uc))
+      {
+        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,
-                  "Got KX: Receiver doing rekeying.\n");
+                  "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 (sender->num_secrets > MAX_SECRETS)
+      {
+        if (0 == purge_secrets (sender->ss_tail))
+        {
+          // No secret purged. Delete oldest.
+          secret_destroy (sender->ss_tail);
+        }
+      }
     }
   }
 }
@@ -2601,31 +2291,19 @@ do_pad (gcry_cipher_hd_t out_cipher, char *dgram, size_t pad_size)
 }
 
 
-/**
- * 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)
+send_msg_with_kx (const struct GNUNET_MessageHeader *msg, struct
+                  ReceiverAddress *receiver)
 {
-  struct ReceiverAddress *receiver = impl_state;
   uint16_t msize = ntohs (msg->size);
   struct UdpHandshakeSignature uhs;
   struct UDPConfirmation uc;
   struct InitialKX kx;
-  struct GNUNET_CRYPTO_EcdhePrivateKey epriv;
   char dgram[receiver->kx_mtu + sizeof(uc) + sizeof(kx)];
   size_t dpos;
   gcry_cipher_hd_t out_cipher;
   struct SharedSecret *ss;
 
-  GNUNET_assert (mq == receiver->kx_mq);
   if (msize > receiver->kx_mtu)
   {
     GNUNET_break (0);
@@ -2636,13 +2314,16 @@ mq_send_kx (struct GNUNET_MQ_Handle *mq,
   reschedule_receiver_timeout (receiver);
 
   /* setup key material */
-  GNUNET_CRYPTO_ecdhe_key_create (&epriv);
 
-  ss = setup_shared_secret_enc (&epriv, receiver, GNUNET_YES);
+  ss = setup_shared_secret_ephemeral (&uhs.ephemeral, receiver);
 
   if (receiver->num_secrets > MAX_SECRETS)
   {
-    destroy_all_secrets (ss, GNUNET_YES);
+    if (0 == purge_secrets (receiver->ss_tail))
+    {
+      // No secret purged. Delete oldest.
+      secret_destroy (receiver->ss_tail);
+    }
   }
 
   setup_cipher (&ss->master, 0, &out_cipher);
@@ -2655,7 +2336,6 @@ mq_send_kx (struct GNUNET_MQ_Handle *mq,
   uhs.purpose.size = htonl (sizeof(uhs));
   uhs.sender = my_identity;
   uhs.receiver = receiver->target;
-  GNUNET_CRYPTO_ecdhe_key_get_public (&epriv, &uhs.ephemeral);
   uhs.monotonic_time = uc.monotonic_time;
   GNUNET_CRYPTO_eddsa_sign (my_private_key,
                             &uhs,
@@ -2679,10 +2359,6 @@ mq_send_kx (struct GNUNET_MQ_Handle *mq,
   GNUNET_assert (
     0 == gcry_cipher_gettag (out_cipher, kx.gcm_tag, sizeof(kx.gcm_tag)));
   gcry_cipher_close (out_cipher);
-  if (GNUNET_NO == receiver->rekeying)
-    kx.rekeying = GNUNET_NO;
-  else
-    kx.rekeying = GNUNET_YES;
   memcpy (dgram, &kx, sizeof(kx));
   if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock,
                                           dgram,
@@ -2695,168 +2371,51 @@ mq_send_kx (struct GNUNET_MQ_Handle *mq,
               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
-check_for_rekeying (struct ReceiverAddress *receiver, struct UDPBox *box)
+mq_send_kx (struct GNUNET_MQ_Handle *mq,
+            const struct GNUNET_MessageHeader *msg,
+            void *impl_state)
 {
+  struct ReceiverAddress *receiver = impl_state;
 
-  struct GNUNET_TIME_Relative rt;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Timeout is %llu\n.",
-              (unsigned long long) receiver->rekey_timeout.abs_value_us);
-
-  if (0 == receiver->rekey_timeout.abs_value_us)
-  {
-    receiver->rekey_timeout = GNUNET_TIME_relative_to_absolute (
-      rekey_interval);
-  }
-  else
-  {
-    rt = GNUNET_TIME_absolute_get_remaining (receiver->rekey_timeout);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Relative time is %llu and timeout is %llu\n.",
-                (unsigned long long) rt.rel_value_us,
-                (unsigned long long) receiver->rekey_timeout.abs_value_us);
-
-    if ((0 == rt.rel_value_us) || (receiver->rekey_send_bytes >
-                                   rekey_max_bytes) )
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Bytes send %llu greater than %llu max bytes\n.",
-                  (unsigned long long) receiver->rekey_send_bytes,
-                  rekey_max_bytes);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Relative time is %llu and timeout is %llu\n.",
-                  (unsigned long long) rt.rel_value_us,
-                  (unsigned long long) receiver->rekey_timeout.abs_value_us);
-
-      receiver->rekey_timeout.abs_value_us = 0;
-      receiver->rekey_send_bytes = 0;
-      receiver->ss_rekey = NULL;
-      // destroy_all_secrets (ss, GNUNET_NO);
-      receiver->rekeying = GNUNET_YES;
-      receiver->rekey_acks_available = receiver->acks_available;
-      box->rekeying = GNUNET_YES;
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Sender started rekeying.\n");
-      if (GNUNET_YES == box->rekeying)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "Sending rekeying with kid %s\n",
-                    GNUNET_sh2s (&box->kid));
-    }
-  }
+  GNUNET_assert (mq == receiver->kx_mq);
+  send_msg_with_kx (msg, receiver);
+  GNUNET_MQ_impl_send_continue (mq);
 }
 
 
 static void
-send_UDPRekey (struct ReceiverAddress *receiver, struct SharedSecret *ss)
-{
-  uint8_t is_ss_rekey_sequence_allowed_zero = GNUNET_NO;
-  uint8_t is_acks_available_below = GNUNET_NO;
-  uint8_t send_rekey = GNUNET_NO;
-  uint16_t not_below;
-  struct GNUNET_CRYPTO_EcdhePrivateKey epriv;
-  struct UDPRekey *rekey;
-  size_t dpos;
-
-  char rekey_dgram[sizeof(struct UDPRekey) + receiver->d_mtu];
-
-  if (NULL != receiver->ss_rekey)
-  {
-    not_below = (receiver->rekey_acks_available
-                 - (receiver->rekey_acks_available % 3)) / 3;
-    is_ss_rekey_sequence_allowed_zero = (0 ==
-                                         receiver->ss_rekey->sequence_allowed);
-    is_acks_available_below = (receiver->acks_available >= not_below);
-    send_rekey = (0 == (receiver->acks_available - not_below) % not_below) &&
-                 is_acks_available_below && is_ss_rekey_sequence_allowed_zero;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "send_rekey: %u, %u, %u\n",
-                send_rekey,
-                receiver->rekey_acks_available,
-                receiver->acks_available);
-  }
-  else if (NULL == receiver->ss_rekey)
-  {
-    /* setup key material */
-    GNUNET_CRYPTO_ecdhe_key_create (&epriv);
-    receiver->ss_rekey = setup_shared_secret_enc (&epriv, receiver,
-                                                  GNUNET_NO);
-    receiver->ss_rekey->sequence_allowed = 0;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Setup secret with cmac %s\n",
-                GNUNET_h2s (&(receiver->ss_rekey->cmac)));
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Setup secret with master %s.\n",
-                GNUNET_h2s (&(receiver->ss_rekey->master)));
-  }
-
-  if (send_rekey)
-  {
-    GNUNET_assert (0 != receiver->number_rekeying_kce);
-    gcry_cipher_hd_t rekey_out_cipher;
-
-    while (NULL != ss && ss->sequence_used >= ss->sequence_allowed)
-    {
-      ss = ss->prev;
-    }
-
-    if (NULL != ss)
-    {
-      rekey = (struct UDPRekey *) rekey_dgram;
-      rekey->sender = my_identity;
-      ss->sequence_used++;
-      get_kid (&ss->master, ss->sequence_used, &rekey->kid);
-      receiver->number_rekeying_kce--;
-      setup_cipher (&ss->master, ss->sequence_used, &rekey_out_cipher);
-      /* Append encrypted payload to dgram */
-      dpos = sizeof(struct UDPRekey);
-
-      GNUNET_assert (
-        0 == gcry_cipher_encrypt (rekey_out_cipher, &rekey_dgram[dpos],
-                                  sizeof(receiver->ss_rekey->master),
-                                  &(receiver->ss_rekey->master),
-                                  sizeof(receiver->ss_rekey->master)));
-      dpos += sizeof(receiver->ss_rekey->master);
-      do_pad (rekey_out_cipher, &rekey_dgram[dpos], sizeof(rekey_dgram)
-              - dpos);
-      GNUNET_assert (0 == gcry_cipher_gettag (rekey_out_cipher,
-                                              rekey->gcm_tag,
-                                              sizeof(rekey->gcm_tag)));
-      gcry_cipher_close (rekey_out_cipher);
-
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Sending rekey with kid %s and master %s\n",
-                  GNUNET_sh2s (&rekey->kid),
-                  GNUNET_h2s (&(receiver->ss_rekey->master)));
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Sending rekey with cmac %s\n",
-                  GNUNET_h2s (&(receiver->ss_rekey->cmac)));
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "%u rekey kces left.\n",
-                  receiver->number_rekeying_kce);
+create_rekey (struct ReceiverAddress *receiver, struct SharedSecret *ss, struct
+              UDPRekey *rekey)
+{
+  struct SharedSecret *ss_rekey;
 
-      if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock,
-                                              rekey_dgram,
-                                              sizeof(rekey_dgram),
-                                              receiver->address,
-                                              receiver->address_len))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send");
+  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)));
 
-      receiver->acks_available--;
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "%u receiver->acks_available 1\n",
-                  receiver->acks_available);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Sending UDPRekey to %s\n", GNUNET_a2s (receiver->address,
-                                                          receiver->
-                                                          address_len));
-    }
-  }
+  /* Append encrypted payload to dgram */
+  rekey->header.type = htons (GNUNET_MESSAGE_TYPE_COMMUNICATOR_UDP_REKEY);
+  rekey->header.size = htons (sizeof (struct UDPRekey));
 }
 
 
@@ -2874,6 +2433,9 @@ mq_send_d (struct GNUNET_MQ_Handle *mq,
            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);
@@ -2893,19 +2455,52 @@ mq_send_d (struct GNUNET_MQ_Handle *mq,
   }
   reschedule_receiver_timeout (receiver);
 
+  if (receiver->num_secrets > MAX_SECRETS)
+  {
+    if (0 == purge_secrets (receiver->ss_tail))
+    {
+      // No secret purged. Delete oldest.
+      secret_destroy (receiver->ss_tail);
+    }
+  }
   /* begin "BOX" encryption method, scan for ACKs from tail! */
-  for (struct SharedSecret *ss = receiver->ss_tail; NULL != ss; ss = ss->prev)
+  for (ss = receiver->ss_tail; NULL != ss; ss = ss->prev)
   {
+    size_t payload_len = sizeof(struct UDPBox) + receiver->d_mtu;
+    if (ss->sequence_used >= ss->sequence_allowed)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Skipping ss because no acks to use.\n");
+      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!
+      continue;
+    }
+    if (ss->bytes_sent > rekey_max_bytes * 0.7)
+    {
+      if (ss->rekey_initiated == GNUNET_NO)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "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);
-    if (ss->sequence_used >= ss->sequence_allowed)
-      continue;
 
-    char dgram[sizeof(struct UDPBox) + receiver->d_mtu];
+    char dgram[payload_len];
     struct UDPBox *box;
     gcry_cipher_hd_t out_cipher;
     size_t dpos;
@@ -2916,6 +2511,13 @@ mq_send_d (struct GNUNET_MQ_Handle *mq,
     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;
@@ -2925,53 +2527,26 @@ mq_send_d (struct GNUNET_MQ_Handle *mq,
                                             sizeof(box->gcm_tag)));
     gcry_cipher_close (out_cipher);
 
-    receiver->rekey_send_bytes += sizeof(struct UDPBox) + receiver->d_mtu;
-
-    if (GNUNET_NO == receiver->rekeying)
-      box->rekeying = GNUNET_NO;
-    else
-      box->rekeying = GNUNET_YES;
-
     if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock,
                                             dgram,
-                                            sizeof(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_DEBUG,
-                "Sending UDPBox with payload size %u, %u acks left\n",
+                "Sending UDPBox with payload size %u, %u acks left, %lu bytes sent\n",
                 msize,
-                receiver->acks_available);
-    GNUNET_MQ_impl_send_continue (mq);
+                receiver->acks_available,
+                (unsigned long) ss->bytes_sent);
+    ss->bytes_sent += sizeof (dgram);
     receiver->acks_available--;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "%u receiver->acks_available 2\n",
-                receiver->acks_available);
-    check_for_rekeying (receiver, box);
-    if (0 == receiver->acks_available - receiver->number_rekeying_kce)
-    {
-      /* We have no more ACKs */
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "No more acks\n");
-      if (GNUNET_YES == receiver->rekeying)
-      {
-        receiver->rekeying = GNUNET_NO;
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "Sender stopped rekeying\n");
-
-        if ((NULL != receiver->ss_rekey) && (0 <
-                                             receiver->ss_rekey->
-                                             sequence_allowed) )
-          add_acks_rekey (receiver);
-      }
-    }
-    else if ((GNUNET_YES == receiver->rekeying)  )
-    {
-      send_UDPRekey (receiver, ss);
-    }
-
+    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);
+  GNUNET_MQ_impl_send_continue (mq);
 }
 
 
@@ -3234,16 +2809,6 @@ get_sender_delete_it (void *cls,
   (void) cls;
   (void) target;
 
-  if (NULL != sender->kce_task_rekey)
-  {
-    GNUNET_SCHEDULER_cancel (sender->kce_task_rekey);
-    sender->kce_task_rekey = NULL;
-  }
-  if (NULL != sender->kce_task)
-  {
-    GNUNET_SCHEDULER_cancel (sender->kce_task);
-    sender->kce_task = NULL;
-  }
 
   sender_destroy (sender);
   return GNUNET_OK;
diff --git a/src/transport/gnunet-service-tng.c b/src/transport/gnunet-service-tng.c
index c4711e6fe..f2ee685bc 100644
--- a/src/transport/gnunet-service-tng.c
+++ b/src/transport/gnunet-service-tng.c
@@ -187,20 +187,20 @@
  * the value chosen here might be too aggressively low!
  */
 #define DELAY_WARN_THRESHOLD \
-        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
+  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)
+  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)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
 
 /**
  * We only consider queues as "quality" connections when
@@ -208,53 +208,53 @@
  * the latency of the queue is below this threshold.
  */
 #define DV_QUALITY_RTT_THRESHOLD \
-        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
+  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)
+  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)
+  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)
+  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)
+  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)
+  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)
+  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)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_DAYS, 1)
 
 /**
  * How long until we forget about historic accumulators and thus
@@ -262,7 +262,7 @@
  * active connection experiences without an ACK.
  */
 #define ACK_CUMMULATOR_TIMEOUT \
-        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
 
 /**
  * What is the non-randomized base frequency at which we
@@ -280,13 +280,13 @@
  * When do we forget an invalid address for sure?
  */
 #define MAX_ADDRESS_VALID_UNTIL \
-        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MONTHS, 1)
+  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)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
 
 /**
  * What is the maximum frequency at which we do address validation?
@@ -1774,10 +1774,6 @@ struct DistanceVector
    */
   struct GNUNET_CRYPTO_EcdhePublicKey ephemeral_key;
 
-  /**
-   * Our private ephemeral key.
-   */
-  struct GNUNET_CRYPTO_EcdhePrivateKey private_key;
 };
 
 
@@ -4411,24 +4407,18 @@ check_communicator_backchannel (
 
 
 /**
- * Ensure ephemeral keys in our @a dv are current. If no current one exists,
- * set it up.
+ * Sign ephemeral keys in our @a dv are current.
  *
  * @param[in,out] dv virtual link to update ephemeral for
  */
 static void
-update_ephemeral (struct DistanceVector *dv)
+sign_ephemeral (struct DistanceVector *dv)
 {
   struct EphemeralConfirmationPS ec;
 
-  if (0 !=
-      GNUNET_TIME_absolute_get_remaining (dv->ephemeral_validity).rel_value_us)
-    return;
   dv->monotime = GNUNET_TIME_absolute_get_monotonic (GST_cfg);
   dv->ephemeral_validity =
     GNUNET_TIME_absolute_add (dv->monotime, EPHEMERAL_VALIDITY);
-  GNUNET_CRYPTO_ecdhe_key_create (&dv->private_key);
-  GNUNET_CRYPTO_ecdhe_key_get_public (&dv->private_key, &dv->ephemeral_key);
   ec.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_EPHEMERAL);
   ec.target = dv->target;
   ec.ephemeral_key = dv->ephemeral_key;
@@ -4681,7 +4671,7 @@ dv_setup_key_state_from_km (const struct GNUNET_HashCode *km,
                             const struct GNUNET_ShortHashCode *iv,
                             struct DVKeyState *key)
 {
-  /* must match #dh_key_derive_eph_pub */
+  /* must match what we defive from decapsulated key */
   GNUNET_assert (GNUNET_YES ==
                  GNUNET_CRYPTO_kdf (&key->material,
                                     sizeof(key->material),
@@ -4710,62 +4700,6 @@ dv_setup_key_state_from_km (const struct GNUNET_HashCode *km,
 
 
 /**
- * Derive backchannel encryption key material from @a priv_ephemeral
- * and @a target and @a iv.
- *
- * @param priv_ephemeral ephemeral private key to use
- * @param target the target peer to encrypt to
- * @param iv unique IV to use
- * @param[out] key set to the key material
- * @return GNUNET_OK on success
- */
-static enum GNUNET_GenericReturnValue
-dh_key_derive_eph_pid (
-  const struct GNUNET_CRYPTO_EcdhePrivateKey *priv_ephemeral,
-  const struct GNUNET_PeerIdentity *target,
-  const struct GNUNET_ShortHashCode *iv,
-  struct DVKeyState *key)
-{
-  struct GNUNET_HashCode km;
-
-  if (GNUNET_YES != GNUNET_CRYPTO_ecdh_eddsa (priv_ephemeral,
-                                              &target->public_key,
-                                              &km))
-    return GNUNET_SYSERR;
-  // FIXME: Possibly also add return values here. We are processing
-  // Input from other peers...
-  dv_setup_key_state_from_km (&km, iv, key);
-  return GNUNET_OK;
-}
-
-
-/**
- * Derive backchannel encryption key material from #GST_my_private_key
- * and @a pub_ephemeral and @a iv.
- *
- * @param priv_ephemeral ephemeral private key to use
- * @param target the target peer to encrypt to
- * @param iv unique IV to use
- * @param[out] key set to the key material
- * @return GNUNET_OK on success
- */
-static enum GNUNET_GenericReturnValue
-dh_key_derive_eph_pub (const struct GNUNET_CRYPTO_EcdhePublicKey *pub_ephemeral,
-                       const struct GNUNET_ShortHashCode *iv,
-                       struct DVKeyState *key)
-{
-  struct GNUNET_HashCode km;
-
-  if (GNUNET_YES != GNUNET_CRYPTO_eddsa_ecdh (GST_my_private_key,
-                                              pub_ephemeral,
-                                              &km))
-    return GNUNET_SYSERR;
-  dv_setup_key_state_from_km (&km, iv, key);
-  return GNUNET_OK;
-}
-
-
-/**
  * Do HMAC calculation for backchannel messages over @a data using key
  * material from @a key.
  *
@@ -4882,13 +4816,22 @@ encapsulate_for_dv (struct DistanceVector *dv,
   char enc[sizeof(struct TransportDVBoxPayloadP) + enc_body_size] GNUNET_ALIGN;
   struct DVKeyState *key;
   struct GNUNET_TIME_Relative rtt;
+  struct GNUNET_HashCode k;
 
   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);
+  // 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,
+                                    &k);
+    sign_ephemeral (dv);
+  }
   box_hdr.ephemeral_key = dv->ephemeral_key;
   payload_hdr.sender_sig = dv->sender_sig;
 
@@ -4896,10 +4839,9 @@ encapsulate_for_dv (struct DistanceVector *dv,
                               &box_hdr.iv,
                               sizeof(box_hdr.iv));
   // We are creating this key, so this must work.
-  GNUNET_assert (GNUNET_OK ==
-                 dh_key_derive_eph_pid (&dv->private_key,
-                                        &dv->target,
-                                        &box_hdr.iv, key));
+  // FIXME: Possibly also add return values here. We are processing
+  // Input from other peers...
+  dv_setup_key_state_from_km (&k, &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));
@@ -8322,13 +8264,17 @@ handle_dv_box (void *cls, const struct TransportDVBoxMessage *dvb)
   cmc->total_hops = ntohs (dvb->total_hops);
 
   // DH key derivation with received DV, could be garbage.
-  if (GNUNET_OK !=
-      dh_key_derive_eph_pub (&dvb->ephemeral_key, &dvb->iv, &key))
+  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)
diff --git a/src/transport/meson.build b/src/transport/meson.build
new file mode 100644
index 000000000..d997aad8a
--- /dev/null
+++ b/src/transport/meson.build
@@ -0,0 +1,320 @@
+libgnunettransport_src = ['transport_api_address_to_string.c',
+                          'transport_api_blacklist.c',
+                          'transport_api_core.c',
+                          'transport_api_hello_get.c',
+                          'transport_api_manipulation.c',
+                          'transport_api_monitor_peers.c',
+                          'transport_api_monitor_plugins.c',
+                          'transport_api_offer_hello.c']
+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-tng.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'))
+
+configure_file(input : 'communicator-unix.conf',
+               output : 'communicator-unix.conf',
+               configuration : cdata,
+               install: true,
+               install_dir: pkgcfgdir)
+
+if get_option('monolith')
+  foreach p : libgnunettransport_src #+ libgnunettransportapplication_src + libgnunettransportcore_src + libgnunettransportcommunicator_src + libgnunettransportmonitor_src + gnunetservicetransport_src
+    gnunet_src += 'transport/' + p
+  endforeach
+endif
+
+libgnunettransport = library('gnunettransport',
+        libgnunettransport_src,
+        soversion: '2',
+        version: '2.2.0',
+        dependencies: [libgnunetutil_dep, libgnunetats_dep, libgnunethello_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir'))
+pkg.generate(libgnunettransport, url: 'https://www.gnunet.org',
+             description : 'Provides API for accessing the transport service')
+libgnunettransport_dep = declare_dependency(link_with : libgnunettransport)
+
+libgnunettransporttesting = library('gnunettransporttesting',
+        [
+          'transport-testing.c',
+          'transport-testing-filenames.c',
+          'transport-testing-loggers.c',
+          'transport-testing-main.c',
+          'transport-testing-send.c'
+          ],
+        soversion: '0',
+        version: '0.0.0',
+        dependencies: [libgnunetutil_dep,
+                       libgnunettesting_dep,
+                       libgnunettransport_dep,
+                       libgnunetats_dep,
+                       libgnunethello_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir'))
+
+
+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)
+
+libgnunettransporttesting2 = library('gnunettransporttesting2',
+        [
+          'transport_api_traits.c',
+          'transport_api_cmd_connecting_peers.c',
+          'transport_api_cmd_backchannel_check.c',
+          'transport_api_cmd_start_peer.c',
+          'transport_api_cmd_stop_peer.c',
+          'transport_api_cmd_send_simple.c',
+          'transport_api_cmd_send_simple_performance.c',
+          'transport-testing2.c',
+          'transport-testing-filenames2.c',
+          'transport-testing-loggers2.c',
+          'transport-testing-main2.c',
+          'transport-testing-send2.c',
+          'transport-testing-communicator.c',
+          ],
+        soversion: '0',
+        version: '0.0.0',
+        dependencies: [libgnunetutil_dep,
+                       libgnunettransportapplication_dep,
+                       libgnunettransport_dep,
+                       libgnunetpeerstore_dep,
+                       libgnunetats_dep,
+                       libgnunettesting_dep,
+                       libgnunethello_dep],
+        include_directories: [incdir, configuration_inc],
+        install: true,
+        install_dir: get_option('libdir'))
+libgnunettransporttesting2_dep = declare_dependency(link_with : libgnunettransporttesting2)
+
+executable ('gnunet-service-transport',
+            gnunetservicetransport_src,
+            dependencies: [libgnunettransport_dep, libgnunetutil_dep,
+                           libgnunethello_dep,
+                           libgnunetpeerstore_dep,
+                           m_dep,
+                           libgnunetstatistics_dep,
+                           gcrypt_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,
+                           libgnunetnt_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,
+                           libgnunetnt_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,
+                           libgnunetnt_dep,
+                           libgnunetnat_dep,
+                           gcrypt_dep,
+                           libgnunetutil_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('libdir') / 'gnunet' / 'libexec')
+
+executable ('gnunet-transport',
+            ['gnunet-transport.c'],
+            dependencies: [libgnunettransportcommunicator_dep,
+                           libgnunethello_dep,
+                           libgnunettransport_dep,
+                           libgnunetpeerstore_dep,
+                           libgnunetutil_dep],
+            include_directories: [incdir, configuration_inc],
+            install: true,
+            install_dir: get_option('bindir'))
+
+libgnunettesttransport_cmd_simplesend = library('gnunet_test_transport_plugin_cmd_simple_send',
+    ['test_transport_plugin_cmd_simple_send.c'],
+        dependencies: [
+          libgnunetutil_dep,
+          libgnunettransporttesting2_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_simplesendbc = library('gnunet_test_transport_plugin_cmd_simple_send_broadcast',
+    ['test_transport_plugin_cmd_simple_send_broadcast.c'],
+        dependencies: [
+          libgnunetutil_dep,
+          libgnunettransporttesting2_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_simplesenddv = library('gnunet_test_transport_plugin_cmd_simple_send_dv',
+    ['test_transport_plugin_cmd_simple_send_dv.c'],
+        dependencies: [
+          libgnunetutil_dep,
+          libgnunettransporttesting2_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_simplesendperf = library('gnunet_test_transport_plugin_cmd_simple_send_performance',
+    ['test_transport_plugin_cmd_simple_send_performance.c'],
+        dependencies: [
+          libgnunetutil_dep,
+          libgnunettransporttesting2_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_udpback = library('gnunet_test_transport_plugin_cmd_udp_backchannel',
+    ['test_transport_plugin_cmd_udp_backchannel.c'],
+        dependencies: [
+          libgnunetutil_dep,
+          libgnunettransporttesting2_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,
+          libgnunettransporttesting2_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')
diff --git a/src/transport/plugin_transport_http_common.c b/src/transport/plugin_transport_http_common.c
index 40353daeb..a033985e1 100644
--- a/src/transport/plugin_transport_http_common.c
+++ b/src/transport/plugin_transport_http_common.c
@@ -604,7 +604,7 @@ http_common_plugin_address_to_string (const char *plugin,
   if (addr_str[ntohl (address->urlen) - 1] != '\0')
     return NULL;
   GNUNET_asprintf (&res, "%s.%u.%s", plugin, ntohl (address->options),
-                   (char*)&address[1]);
+                   (char*) &address[1]);
   if (strlen (res) + 1 < 500)
   {
     GNUNET_memcpy (rbuf, res, strlen (res) + 1);
diff --git a/src/transport/plugin_transport_wlan.c b/src/transport/plugin_transport_wlan.c
index 138fb5080..3ac106859 100644
--- a/src/transport/plugin_transport_wlan.c
+++ b/src/transport/plugin_transport_wlan.c
@@ -1873,7 +1873,8 @@ handle_helper_message (void *cls,
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Size of packet is too small (%llu bytes < %llu)\n",
            (unsigned long long) msize,
-           (unsigned long long) sizeof(struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage));
+           (unsigned long long) sizeof(struct
+                                       GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage));
       break;
     }
     rxinfo = (const struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage *) hdr;
diff --git a/src/transport/test_communicator_basic.c b/src/transport/test_communicator_basic.c
index 14d1a4792..fdbad0957 100644
--- a/src/transport/test_communicator_basic.c
+++ b/src/transport/test_communicator_basic.c
@@ -104,13 +104,13 @@ static unsigned int iterations_left[NUM_PEERS];
 #define TIMEOUT_MULTIPLIER 1
 
 #define DELAY \
-        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS,200)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS,200)
 
 #define SHORT_BURST_WINDOW \
-        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,2)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,2)
 
 #define LONG_BURST_WINDOW \
-        GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,2)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,2)
 
 enum TestPhase
 {
@@ -394,7 +394,8 @@ process_statistics (void *cls,
   {
     ret = 2;
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Not enough BOX messages!\n");
+                "Not enough BOX messages! (want: %u, have %llu)\n",
+                9000, value);
     GNUNET_SCHEDULER_shutdown ();
   }
   if ((0 == strcmp ("rekey", test_name)) &&
@@ -405,7 +406,8 @@ process_statistics (void *cls,
   {
     ret = 2;
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Not enough BOX messages!\n");
+                "Not enough BOX messages! (want: %u, have %llu)\n",
+                6000, value);
     GNUNET_SCHEDULER_shutdown ();
   }
   return GNUNET_OK;
@@ -432,11 +434,13 @@ short_test_cb (void *cls)
        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,
-                                                        (burst_packets_short ==
-                                                         num_sent_short[peer_nr])
-                                                        ? NULL
-                                                        : &short_test,
+                                                        NULL,
                                                         cls,
                                                         payload,
                                                         SHORT_MESSAGE_SIZE);
@@ -477,11 +481,13 @@ size_test (void *cls)
   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,
-                                                        (ack[peer_nr] <
-                                                         max_size)
-                                                        ? &size_test
-                                                        : NULL,
+                                                        NULL,
                                                         cls,
                                                         payload,
                                                         ack[peer_nr]);
@@ -511,11 +517,13 @@ long_test_cb (void *cls)
        (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,
-                                                        (burst_packets_long ==
-                                                         num_sent_long[peer_nr])
-                                                        ? NULL
-                                                        : &long_test,
+                                                        NULL,
                                                         cls,
                                                         payload,
                                                         long_message_size);
@@ -784,7 +792,7 @@ add_queue_cb (void *cls,
     return;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Queue established, starting test...\n");
-  if (UINT32_MAX != mtu) /* Message header overhead */
+  if (UINT16_MAX != mtu) /* Message header overhead */
     long_message_size = mtu - sizeof(struct GNUNET_TRANSPORT_SendMessageTo)
                         - sizeof(struct GNUNET_MessageHeader);
   else
@@ -935,7 +943,8 @@ incoming_message_cb (
       if (long_message_size != payload_len)
       {
         LOG (GNUNET_ERROR_TYPE_WARNING,
-             "Ignoring packet with wrong length\n");
+             "Ignoring packet with wrong length (have: %lu, want: %lu)\n",
+             payload_len, long_message_size);
         return;   // Ignore
       }
       num_received_long[peer_nr]++;
@@ -1086,7 +1095,7 @@ main (int argc,
   phase[0] = TP_INIT;
   phase[1] = TP_INIT;
   ret = 1;
-  test_name = GNUNET_TESTING_get_testname_from_underscore (argv[0]);
+  test_name = GNUNET_STRINGS_get_suffix_from_binary_name (argv[0]);
   communicator_name = strchr (test_name, '-');
   communicator_name[0] = '\0';
   communicator_name++;
diff --git a/src/transport/test_communicator_quic_basic_peer1.conf b/src/transport/test_communicator_quic_basic_peer1.conf
new file mode 100644
index 000000000..d43752ecc
--- /dev/null
+++ b/src/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/transport/test_communicator_quic_basic_peer2.conf b/src/transport/test_communicator_quic_basic_peer2.conf
new file mode 100644
index 000000000..4fabc8a86
--- /dev/null
+++ b/src/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/transport/test_communicator_udp_backchannel_peer1.conf b/src/transport/test_communicator_udp_backchannel_peer1.conf
index 59e6d68e3..65f33bd6b 100644
--- a/src/transport/test_communicator_udp_backchannel_peer1.conf
+++ b/src/transport/test_communicator_udp_backchannel_peer1.conf
@@ -39,7 +39,7 @@ BINDTO = 60002
 DISABLE_V6 = YES
 
 [communicator-udp]
-#PREFIX = valgrind --leak-check=full --track-origins=yes
+# PREFIX = valgrind --leak-check=full --track-origins=yes --log-file=/tmp/vg_comm1
 BINDTO = 60002
 DISABLE_V6 = YES
 MAX_QUEUE_LENGTH=5000
diff --git a/src/transport/test_communicator_udp_backchannel_peer2.conf b/src/transport/test_communicator_udp_backchannel_peer2.conf
index 3abf7999b..9875af724 100644
--- a/src/transport/test_communicator_udp_backchannel_peer2.conf
+++ b/src/transport/test_communicator_udp_backchannel_peer2.conf
@@ -39,7 +39,7 @@ BINDTO = 60003
 DISABLE_V6 = YES
 
 [communicator-udp]
-#PREFIX = valgrind --leak-check=full --track-origins=yes
+# PREFIX = valgrind --leak-check=full --track-origins=yes --log-file=/tmp/vg_comm2
 BINDTO = 60003
 DISABLE_V6 = YES
 MAX_QUEUE_LENGTH=5000
diff --git a/src/transport/test_communicator_udp_basic_peer1.conf b/src/transport/test_communicator_udp_basic_peer1.conf
index c6ff024ee..6968b3aef 100644
--- a/src/transport/test_communicator_udp_basic_peer1.conf
+++ b/src/transport/test_communicator_udp_basic_peer1.conf
@@ -32,7 +32,8 @@ PORT = 62089
 UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_1.sock
 
 [communicator-udp]
-#PREFIX = valgrind --leak-check=full --track-origins=yes
+# PREFIX = valgrind --leak-check=full --track-origins=yes --log-file=/tmp/vg_com1
 BINDTO = 60002
 DISABLE_V6 = YES
 MAX_QUEUE_LENGTH=5000
+
diff --git a/src/transport/test_communicator_udp_basic_peer2.conf b/src/transport/test_communicator_udp_basic_peer2.conf
index b353b03e9..781bfa7da 100644
--- a/src/transport/test_communicator_udp_basic_peer2.conf
+++ b/src/transport/test_communicator_udp_basic_peer2.conf
@@ -33,7 +33,7 @@ PORT = 62090
 UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-service-resolver_test_2.sock
 
 [communicator-udp]
-#PREFIX = valgrind --leak-check=full --track-origins=yes
+# 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/transport/test_communicator_udp_rekey_peer1.conf b/src/transport/test_communicator_udp_rekey_peer1.conf
index 6bfeafe33..9b0fa7497 100644
--- a/src/transport/test_communicator_udp_rekey_peer1.conf
+++ b/src/transport/test_communicator_udp_rekey_peer1.conf
@@ -45,7 +45,8 @@ REKEY_INTERVAL = 100ms
 BINDTO = 60002
 DISABLE_V6 = YES
 MAX_QUEUE_LENGTH=5000
-REKEY_MAX_BYTES=9MiB
+REKEY_INTERVAL = 100ms
+REKEY_MAX_BYTES=9KiB
 
 [communicator-test]
 BACKCHANNEL_ENABLED = YES
diff --git a/src/transport/test_communicator_udp_rekey_peer2.conf b/src/transport/test_communicator_udp_rekey_peer2.conf
index 474ca0c15..383ab19d2 100644
--- a/src/transport/test_communicator_udp_rekey_peer2.conf
+++ b/src/transport/test_communicator_udp_rekey_peer2.conf
@@ -45,7 +45,8 @@ REKEY_INTERVAL = 100ms
 BINDTO = 60003
 DISABLE_V6 = YES
 MAX_QUEUE_LENGTH=5000
-REKEY_MAX_BYTES=9MiB
+REKEY_INTERVAL = 100ms
+REKEY_MAX_BYTES=9KiB
 
 [communicator-test]
 BACKCHANNEL_ENABLED = YES
diff --git a/src/transport/test_transport_api2.c b/src/transport/test_transport_api2.c
index e1606e0be..4d423f7c2 100644
--- a/src/transport/test_transport_api2.c
+++ b/src/transport/test_transport_api2.c
@@ -28,7 +28,7 @@
  * C code apparently.
  */
 #include "platform.h"
-//#include "gnunet_transport_service.h"
+// #include "gnunet_transport_service.h"
 #include "transport-testing2.h"
 
 /**
diff --git a/src/transport/test_transport_plugin_cmd_nat_upnp.c b/src/transport/test_transport_plugin_cmd_nat_upnp.c
index 5c5e71e85..31206e63f 100644
--- a/src/transport/test_transport_plugin_cmd_nat_upnp.c
+++ b/src/transport/test_transport_plugin_cmd_nat_upnp.c
@@ -90,7 +90,7 @@ handle_test (void *cls,
 struct GNUNET_TESTING_BarrierList*
 get_waiting_for_barriers ()
 {
-  struct GNUNET_TESTING_BarrierList* barriers;
+  struct GNUNET_TESTING_BarrierList*barriers;
   struct GNUNET_TESTING_BarrierListEntry *ble;
 
   barriers = GNUNET_new (struct GNUNET_TESTING_BarrierList);
@@ -209,7 +209,7 @@ all_local_tests_prepared ()
  *        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 
+ * @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.
  */
@@ -358,9 +358,9 @@ start_testcase (GNUNET_TESTING_cmd_helper_write_cb write_message,
   ts->write_message = write_message;
 
   is = GNUNET_TESTING_run (commands,
-                      TIMEOUT,
-                      &handle_result,
-                      ts);
+                           TIMEOUT,
+                           &handle_result,
+                           ts);
   return is;
 }
 
diff --git a/src/transport/test_transport_plugin_cmd_simple_send.c b/src/transport/test_transport_plugin_cmd_simple_send.c
index 0c9bfa890..d83c539fa 100644
--- a/src/transport/test_transport_plugin_cmd_simple_send.c
+++ b/src/transport/test_transport_plugin_cmd_simple_send.c
@@ -90,7 +90,7 @@ handle_test (void *cls,
 struct GNUNET_TESTING_BarrierList *
 get_waiting_for_barriers ()
 {
-  //No Barrier
+  // No Barrier
   return GNUNET_new (struct GNUNET_TESTING_BarrierList);
 }
 
@@ -327,9 +327,9 @@ start_testcase (GNUNET_TESTING_cmd_helper_write_cb write_message,
   ts->write_message = write_message;
 
   is = GNUNET_TESTING_run (commands,
-                      TIMEOUT,
-                      &handle_result,
-                      ts);
+                           TIMEOUT,
+                           &handle_result,
+                           ts);
   return is;
 }
 
diff --git a/src/transport/test_transport_plugin_cmd_simple_send_broadcast.c b/src/transport/test_transport_plugin_cmd_simple_send_broadcast.c
index 7381b1d7e..7000851c4 100644
--- a/src/transport/test_transport_plugin_cmd_simple_send_broadcast.c
+++ b/src/transport/test_transport_plugin_cmd_simple_send_broadcast.c
@@ -90,7 +90,7 @@ handle_test (void *cls,
 struct GNUNET_TESTING_BarrierList *
 get_waiting_for_barriers ()
 {
-  //No Barrier
+  // No Barrier
   return GNUNET_new (struct GNUNET_TESTING_BarrierList);
 }
 
@@ -147,12 +147,11 @@ static void *
 notify_connect (struct GNUNET_TESTING_Interpreter *is,
                 const struct GNUNET_PeerIdentity *peer)
 {
-  const struct GNUNET_TESTING_AsyncContext *ac;
+  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");
 
@@ -165,9 +164,9 @@ notify_connect (struct GNUNET_TESTING_Interpreter *is,
                 "notify_connect running\n");
     GNUNET_assert  (NULL != ac);
     if (NULL == ac->cont)
-      GNUNET_TESTING_async_fail ((struct GNUNET_TESTING_AsyncContext *) ac);
+      GNUNET_TESTING_async_fail (ac);
     else
-      GNUNET_TESTING_async_finish ((struct GNUNET_TESTING_AsyncContext *) ac);
+      GNUNET_TESTING_async_finish (ac);
   }
   else
   {
@@ -179,7 +178,7 @@ notify_connect (struct GNUNET_TESTING_Interpreter *is,
          cmd->label);
     GNUNET_TESTING_get_trait_block_state (
       cmd,
-      (const struct GNUNET_TESTING_BlockState  **) &bs);
+      &bs);
 
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "block state %u\n",
@@ -353,9 +352,9 @@ start_testcase (GNUNET_TESTING_cmd_helper_write_cb write_message,
   ts->write_message = write_message;
 
   is = GNUNET_TESTING_run (commands,
-                      TIMEOUT,
-                      &handle_result,
-                      ts);
+                           TIMEOUT,
+                           &handle_result,
+                           ts);
   return is;
 }
 
diff --git a/src/transport/test_transport_plugin_cmd_simple_send_dv.c b/src/transport/test_transport_plugin_cmd_simple_send_dv.c
index ac3e8b24b..c07fd3cf4 100644
--- a/src/transport/test_transport_plugin_cmd_simple_send_dv.c
+++ b/src/transport/test_transport_plugin_cmd_simple_send_dv.c
@@ -113,7 +113,7 @@ handle_test (void *cls,
     GNUNET_TESTING_get_trait_async_context (&block_receive,
                                             &ac_block);
 
-    if ( connected == number_received)
+    if (connected == number_received)
     {
       if (NULL != ac_block->is)
       {
@@ -142,7 +142,7 @@ handle_test (void *cls,
 struct GNUNET_TESTING_BarrierList *
 get_waiting_for_barriers ()
 {
-  //No Barrier
+  // No Barrier
   return GNUNET_new (struct GNUNET_TESTING_BarrierList);
 }
 
@@ -201,19 +201,21 @@ notify_connect (struct GNUNET_TESTING_Interpreter *is,
 {
   const struct ConnectPeersState *cps;
   const struct GNUNET_TESTING_Command *cmd;
-  void *ret = NULL;
 
   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_get_trait_connect_peer_state (cmd,
                                                  &cps);
   cps->notify_connect (is,
                        peer);
-
-  return ret;
+  return NULL;
 }
 
 
@@ -382,9 +384,9 @@ start_testcase (GNUNET_TESTING_cmd_helper_write_cb write_message,
   ts->write_message = write_message;
 
   is = GNUNET_TESTING_run (commands,
-                      TIMEOUT,
-                      &handle_result,
-                      ts);
+                           TIMEOUT,
+                           &handle_result,
+                           ts);
   return is;
 }
 
diff --git a/src/transport/test_transport_plugin_cmd_udp_backchannel.c b/src/transport/test_transport_plugin_cmd_udp_backchannel.c
index 5f411e20e..303790afc 100644
--- a/src/transport/test_transport_plugin_cmd_udp_backchannel.c
+++ b/src/transport/test_transport_plugin_cmd_udp_backchannel.c
@@ -155,6 +155,7 @@ notify_connect (struct GNUNET_TESTING_Interpreter *is,
   return ret;
 }
 
+
 /**
  * Callback to set the flag indicating all peers are prepared to finish. Will be called via the plugin api.
  */
@@ -173,6 +174,7 @@ all_local_tests_prepared ()
                                   GNUNET_TESTING_AsyncContext *) &lfs->ac);
 }
 
+
 /**
  * Function to start a local test case.
  *
diff --git a/src/transport/test_transport_start_with_config.c b/src/transport/test_transport_start_with_config.c
index a2c692dbc..349cd65a5 100644
--- a/src/transport/test_transport_start_with_config.c
+++ b/src/transport/test_transport_start_with_config.c
@@ -94,13 +94,13 @@ main (int argc,
                                       topology_data_script,
                                       &read_file),
     GNUNET_TESTING_cmd_netjail_start_cmds_helper ("netjail-start-testbed",
-                                                     topology,
-                                                     &read_file,
-                                                     topology_data_script,
-                                                     TIMEOUT),
+                                                  topology,
+                                                  &read_file,
+                                                  topology_data_script,
+                                                  TIMEOUT),
     GNUNET_TESTING_cmd_stop_cmds_helper ("stop-testbed",
-                                            "netjail-start-testbed",
-                                            topology),
+                                         "netjail-start-testbed",
+                                         topology),
     GNUNET_TESTING_cmd_netjail_stop ("netjail-stop",
                                      topology_data_script,
                                      &read_file),
diff --git a/src/transport/transport-testing-communicator.c b/src/transport/transport-testing-communicator.c
index 1bf88bb3d..26895e457 100644
--- a/src/transport/transport-testing-communicator.c
+++ b/src/transport/transport-testing-communicator.c
@@ -676,8 +676,13 @@ 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);
-  // NOP
 }
 
 
@@ -772,6 +777,7 @@ shutdown_process (struct GNUNET_OS_Process *proc)
   GNUNET_OS_process_destroy (proc);
 }
 
+
 /**
  * @brief Task run at shutdown to kill the statistics process
  *
@@ -784,6 +790,7 @@ shutdown_statistics (void *cls)
   shutdown_process (proc);
 }
 
+
 /**
  * @brief Task run at shutdown to kill the peerstore process
  *
@@ -796,6 +803,7 @@ shutdown_peerstore (void *cls)
   shutdown_process (proc);
 }
 
+
 /**
  * @brief Task run at shutdown to kill a communicator process
  *
@@ -913,6 +921,7 @@ resolver_start (struct
 
 }
 
+
 /**
  * @brief Start Statistics
  *
@@ -942,6 +951,7 @@ statistics_start (
   GNUNET_free (binary);
 }
 
+
 /**
  * @brief Start Peerstore
  *
@@ -971,6 +981,7 @@ peerstore_start (
   GNUNET_free (binary);
 }
 
+
 /**
  * @brief Start NAT
  *
@@ -1160,8 +1171,9 @@ GNUNET_TRANSPORT_TESTING_transport_communicator_send
   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)
@@ -1188,19 +1200,28 @@ GNUNET_TRANSPORT_TESTING_transport_communicator_send
       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), 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
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending message\n");
+  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, 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 = htonl (tc_queue->qid);
+  msg->qid = tc_queue->qid;
   msg->mid = tc_queue->mid++;
   msg->receiver = tc_queue->peer_id;
   mh = (struct GNUNET_MessageHeader *) &msg[1];
diff --git a/src/transport/transport-testing-communicator.h b/src/transport/transport-testing-communicator.h
index 1875258b4..122ac3efa 100644
--- a/src/transport/transport-testing-communicator.h
+++ b/src/transport/transport-testing-communicator.h
@@ -282,6 +282,16 @@ struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle
   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;
diff --git a/src/transport/transport-testing2.c b/src/transport/transport-testing2.c
index 566e0db71..ec27ac8ba 100644
--- a/src/transport/transport-testing2.c
+++ b/src/transport/transport-testing2.c
@@ -329,6 +329,7 @@ notify_disconnect (void *cls,
   }
 }
 
+
 static void
 retrieve_hello (void *cls);
 
diff --git a/src/transport/transport.conf.in b/src/transport/transport.conf.in
index c6b207ad7..96b87e266 100644
--- a/src/transport/transport.conf.in
+++ b/src/transport/transport.conf.in
@@ -235,3 +235,7 @@ INTERFACE = hci0
 # Real hardware, no testing
 TESTMODE = 0
 TESTING_IGNORE_KEYS = ACCEPT_FROM;
+
+
+[communicator-quic]
+BINDTO = 127.0.0.1
\ No newline at end of file
diff --git a/src/transport/transport_api_cmd_backchannel_check.c b/src/transport/transport_api_cmd_backchannel_check.c
index d672e3ae8..1bdb8817f 100644
--- a/src/transport/transport_api_cmd_backchannel_check.c
+++ b/src/transport/transport_api_cmd_backchannel_check.c
@@ -330,6 +330,7 @@ will_the_other_node_connect_via_udp (
   return GNUNET_NO;
 }
 
+
 static void
 add_search_string (struct CheckState *cs, const struct
                    GNUNET_TESTING_NetjailNode *node)
diff --git a/src/transport/transport_api_cmd_connecting_peers.c b/src/transport/transport_api_cmd_connecting_peers.c
index 8ff206a23..33991bc29 100644
--- a/src/transport/transport_api_cmd_connecting_peers.c
+++ b/src/transport/transport_api_cmd_connecting_peers.c
@@ -139,10 +139,10 @@ connect_peers_run (void *cls,
           char *rest2;
           char *address;
 
-          prefix = strtok(addr, "_");
-          rest = strtok(NULL, "_");
-          rest2 = strtok(rest, "-");
-          address = strtok(NULL, "-");
+          prefix = strtok (addr, "_");
+          rest = strtok (NULL, "_");
+          rest2 = strtok (rest, "-");
+          address = strtok (NULL, "-");
 
           GNUNET_asprintf (&addr_and_port,
                            "%s-%s:0",
@@ -186,20 +186,23 @@ notify_connect (struct GNUNET_TESTING_Interpreter *is,
   const struct GNUNET_TESTING_Command *cmd;
   struct ConnectPeersState *cps;
   struct GNUNET_PeerIdentity *peer_connection;
-  struct GNUNET_TESTING_NodeConnection *pos_connection;
   unsigned int num;
   unsigned int con_num;
   void *ret = NULL;
 
   cmd = GNUNET_TESTING_interpreter_lookup_command_all (is,
                                                        "connect-peers");
-  cps = cmd->cls;
+  cps = cmd->cls; // WTF? Never go directly into cls of another command! FIXME!
   con_num = cps->con_num_notified;
-  for (pos_connection = cps->node_connections_head; NULL != pos_connection;
+  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);
+    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++;
diff --git a/src/transport/transport_api_cmd_start_peer.c b/src/transport/transport_api_cmd_start_peer.c
index c4098e26d..54e204a21 100644
--- a/src/transport/transport_api_cmd_start_peer.c
+++ b/src/transport/transport_api_cmd_start_peer.c
@@ -385,7 +385,7 @@ start_peer_cleanup (void *cls)
     GNUNET_free (sps->handlers);
     sps->handlers = NULL;
   }
-  //TODO Investigate why this caused problems during shutdown.
+  // TODO Investigate why this caused problems during shutdown.
   /*if (NULL != sps->cfg)
   {
     GNUNET_CONFIGURATION_destroy (sps->cfg);