3 files changed, 504 insertions, 821 deletions

diff --git a/src/cadet/gnunet-service-cadet_channel.c b/src/cadet/gnunet-service-cadet_channel.c
index 847a217c7..664b8a7c1 100644
--- a/src/cadet/gnunet-service-cadet_channel.c
+++ b/src/cadet/gnunet-service-cadet_channel.c
@@ -41,23 +41,26 @@
 #include "gnunet-service-cadet_tunnels.h"
 #include "gnunet-service-cadet_paths.h"
 
-#define LOG(level,...) GNUNET_log_from (level,"cadet-chn",__VA_ARGS__)
+#define LOG(level, ...) GNUNET_log_from (level, "cadet-chn", __VA_ARGS__)
 
 /**
  * How long do we initially wait before retransmitting?
  */
-#define CADET_INITIAL_RETRANSMIT_TIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 250)
+#define CADET_INITIAL_RETRANSMIT_TIME \
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)
 
 /**
  * How long do we wait before dropping state about incoming
  * connection to closed port?
  */
-#define TIMEOUT_CLOSED_PORT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30)
+#define TIMEOUT_CLOSED_PORT \
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
 
 /**
  * How long do we wait at least before retransmitting ever?
  */
-#define MIN_RTT_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 75)
+#define MIN_RTT_DELAY \
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 75)
 
 /**
  * Maximum message ID into the future we accept for out-of-order messages.
@@ -164,7 +167,6 @@ struct CadetReliableMessage
    * yet transmitted ever, otherwise the number of (re) transmissions.
    */
   int num_transmissions;
-
 };
 
 
@@ -193,7 +195,6 @@ struct CadetOutOfOrderMessage
    * The envelope with the payload of the out-of-order message
    */
   struct GNUNET_MQ_Envelope *env;
-
 };
 
 
@@ -238,7 +239,6 @@ struct CadetChannelClient
    * Can we send data to the client?
    */
   int client_ready;
-
 };
 
 
@@ -368,7 +368,7 @@ struct CadetChannel
    * Is the tunnel out-of-order?
    */
   int out_of_order;
-  
+
   /**
    * Is this channel a loopback channel, where the destination is us again?
    */
@@ -380,7 +380,6 @@ struct CadetChannel
    * empty.
    */
   int destroy;
-
 };
 
 
@@ -400,12 +399,16 @@ GCCH_2s (const struct CadetChannel *ch)
                    sizeof (buf),
                    "Channel %s:%s ctn:%X(%X/%X)",
                    (GNUNET_YES == ch->is_loopback)
-                   ? "loopback"
-                   : GNUNET_i2s (GCP_get_id (GCT_get_destination (ch->t))),
+                     ? "loopback"
+                     : GNUNET_i2s (GCP_get_id (GCT_get_destination (ch->t))),
                    GNUNET_h2s (&ch->port),
                    ch->ctn,
-                   (NULL == ch->owner) ? 0 : ntohl (ch->owner->ccn.channel_of_client),
-                   (NULL == ch->dest) ? 0 : ntohl (ch->dest->ccn.channel_of_client));
+                   (NULL == ch->owner)
+                     ? 0
+                     : ntohl (ch->owner->ccn.channel_of_client),
+                   (NULL == ch->dest)
+                     ? 0
+                     : ntohl (ch->dest->ccn.channel_of_client));
   return buf;
 }
 
@@ -421,20 +424,15 @@ GCCH_2s (const struct CadetChannel *ch)
  */
 void
 GCCH_hash_port (struct GNUNET_HashCode *h_port,
-                const struct GNUNET_HashCode *port,
-                const struct GNUNET_PeerIdentity *listener)
+                const struct GNUNET_HashCode *port,
+                const struct GNUNET_PeerIdentity *listener)
 {
   struct GNUNET_HashContext *hc;
 
   hc = GNUNET_CRYPTO_hash_context_start ();
-  GNUNET_CRYPTO_hash_context_read (hc,
-                                   port,
-                                   sizeof (*port));
-  GNUNET_CRYPTO_hash_context_read (hc,
-                                   listener,
-                                   sizeof (*listener));
-  GNUNET_CRYPTO_hash_context_finish (hc,
-                                     h_port);
+  GNUNET_CRYPTO_hash_context_read (hc, port, sizeof (*port));
+  GNUNET_CRYPTO_hash_context_read (hc, listener, sizeof (*listener));
+  GNUNET_CRYPTO_hash_context_finish (hc, h_port);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Calculated port hash %s\n",
        GNUNET_h2s (h_port));
@@ -467,9 +465,7 @@ free_channel_client (struct CadetChannelClient *ccc)
 
   while (NULL != (com = ccc->head_recv))
   {
-    GNUNET_CONTAINER_DLL_remove (ccc->head_recv,
-                                 ccc->tail_recv,
-                                 com);
+    GNUNET_CONTAINER_DLL_remove (ccc->head_recv, ccc->tail_recv, com);
     ccc->num_recv--;
     GNUNET_MQ_discard (com->env);
     GNUNET_free (com);
@@ -496,16 +492,13 @@ channel_destroy (struct CadetChannel *ch)
       GCT_send_cancel (crm->qe);
       crm->qe = NULL;
     }
-    GNUNET_CONTAINER_DLL_remove (ch->head_sent,
-                                 ch->tail_sent,
-                                 crm);
+    GNUNET_CONTAINER_DLL_remove (ch->head_sent, ch->tail_sent, crm);
     GNUNET_free (crm->data_message);
     GNUNET_free (crm);
   }
   if (CADET_CHANNEL_LOOSE == ch->state)
   {
-    GSC_drop_loose_channel (&ch->h_port,
-                            ch);
+    GSC_drop_loose_channel (&ch->h_port, ch);
   }
   if (NULL != ch->owner)
   {
@@ -534,9 +527,7 @@ channel_destroy (struct CadetChannel *ch)
   }
   if (GNUNET_NO == ch->is_loopback)
   {
-    GCT_remove_channel (ch->t,
-                        ch,
-                        ch->ctn);
+    GCT_remove_channel (ch->t, ch, ch->ctn);
     ch->t = NULL;
   }
   GNUNET_free (ch);
@@ -572,12 +563,9 @@ channel_open_sent_cb (void *cls,
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Sent CADET_CHANNEL_OPEN on %s, retrying in %s\n",
        GCCH_2s (ch),
-       GNUNET_STRINGS_relative_time_to_string (ch->retry_time,
-                                               GNUNET_YES));
-  ch->retry_control_task
-    = GNUNET_SCHEDULER_add_delayed (ch->retry_time,
-                                    &send_channel_open,
-                                    ch);
+       GNUNET_STRINGS_relative_time_to_string (ch->retry_time, GNUNET_YES));
+  ch->retry_control_task =
+    GNUNET_SCHEDULER_add_delayed (ch->retry_time, &send_channel_open, ch);
 }
 
 
@@ -598,17 +586,15 @@ send_channel_open (void *cls)
        GCCH_2s (ch));
   msgcc.header.size = htons (sizeof (msgcc));
   msgcc.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN);
-  //TODO This will be removed in a major release, because this will be a protocol breaking change. We shift here to be compatible with GNUNET_CADET_OPTION_RELIABLE that was removed, and to already use the newly introduced options.
-  msgcc.opt = GNUNET_MQ_PREF_RELIABLE >> 10;
+  //TODO This will be removed in a major release, because this will be a protocol breaking change. We set the deprecated "reliable" bit here that was removed.
+  msgcc.opt = 2;
   msgcc.h_port = ch->h_port;
   msgcc.ctn = ch->ctn;
   ch->state = CADET_CHANNEL_OPEN_SENT;
   if (NULL != ch->last_control_qe)
     GCT_send_cancel (ch->last_control_qe);
-  ch->last_control_qe = GCT_send (ch->t,
-                                  &msgcc.header,
-                                  &channel_open_sent_cb,
-                                  ch);
+  ch->last_control_qe =
+    GCT_send (ch->t, &msgcc.header, &channel_open_sent_cb, ch);
   GNUNET_assert (NULL == ch->retry_control_task);
 }
 
@@ -630,9 +616,7 @@ GCCH_tunnel_up (struct CadetChannel *ch)
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Tunnel up, sending CHANNEL_OPEN on %s now\n",
        GCCH_2s (ch));
-  ch->retry_control_task
-    = GNUNET_SCHEDULER_add_now (&send_channel_open,
-                                ch);
+  ch->retry_control_task = GNUNET_SCHEDULER_add_now (&send_channel_open, ch);
 }
 
 
@@ -663,54 +647,45 @@ GCCH_channel_local_new (struct CadetClient *owner,
 
   ch = GNUNET_new (struct CadetChannel);
   ch->mid_recv.mid = htonl (1); /* The OPEN_ACK counts as message 0! */
-  ch->nobuffer = GNUNET_NO ;
+  ch->nobuffer = GNUNET_NO;
   ch->reliable = GNUNET_YES;
-  ch->out_of_order = GNUNET_NO ;
-  ch->max_pending_messages = (ch->nobuffer) ? 1 : 4; /* FIXME: 4!? Do not hardcode! */
+  ch->out_of_order = GNUNET_NO;
+  ch->max_pending_messages =
+    (ch->nobuffer) ? 1 : 4; /* FIXME: 4!? Do not hardcode! */
   ch->owner = ccco;
   ch->port = *port;
-  GCCH_hash_port (&ch->h_port,
-                  port,
-                  GCP_get_id (destination));
-  if (0 == GNUNET_memcmp (&my_full_id,
-                   GCP_get_id (destination)))
+  GCCH_hash_port (&ch->h_port, port, GCP_get_id (destination));
+  if (0 == GNUNET_memcmp (&my_full_id, GCP_get_id (destination)))
   {
     struct OpenPort *op;
 
     ch->is_loopback = GNUNET_YES;
-    op = GNUNET_CONTAINER_multihashmap_get (open_ports,
-                                            &ch->h_port);
+    op = GNUNET_CONTAINER_multihashmap_get (open_ports, &ch->h_port);
     if (NULL == op)
     {
       /* port closed, wait for it to possibly open */
       ch->state = CADET_CHANNEL_LOOSE;
-      (void) GNUNET_CONTAINER_multihashmap_put (loose_channels,
-                                                &ch->h_port,
-                                                ch,
-                                                GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+      (void) GNUNET_CONTAINER_multihashmap_put (
+        loose_channels,
+        &ch->h_port,
+        ch,
+        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Created loose incoming loopback channel to port %s\n",
            GNUNET_h2s (&ch->port));
     }
     else
     {
-      GCCH_bind (ch,
-                 op->c,
-                 &op->port);
+      GCCH_bind (ch, op->c, &op->port);
     }
   }
   else
   {
-    ch->t = GCP_get_tunnel (destination,
-                            GNUNET_YES);
+    ch->t = GCP_get_tunnel (destination, GNUNET_YES);
     ch->retry_time = CADET_INITIAL_RETRANSMIT_TIME;
-    ch->ctn = GCT_add_channel (ch->t,
-                               ch);
+    ch->ctn = GCT_add_channel (ch->t, ch);
   }
-  GNUNET_STATISTICS_update (stats,
-                            "# channels",
-                            1,
-                            GNUNET_NO);
+  GNUNET_STATISTICS_update (stats, "# channels", 1, GNUNET_NO);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Created channel to port %s at peer %s for %s using %s\n",
        GNUNET_h2s (port),
@@ -767,27 +742,24 @@ GCCH_channel_incoming_new (struct CadetTunnel *t,
   ch->nobuffer = GNUNET_NO;
   ch->reliable = GNUNET_YES;
   ch->out_of_order = GNUNET_NO;
-  ch->max_pending_messages = (ch->nobuffer) ? 1 : 4; /* FIXME: 4!? Do not hardcode! */
-  GNUNET_STATISTICS_update (stats,
-                            "# channels",
-                            1,
-                            GNUNET_NO);
-
-  op = GNUNET_CONTAINER_multihashmap_get (open_ports,
-                                          h_port);
+  ch->max_pending_messages =
+    (ch->nobuffer) ? 1 : 4; /* FIXME: 4!? Do not hardcode! */
+  GNUNET_STATISTICS_update (stats, "# channels", 1, GNUNET_NO);
+
+  op = GNUNET_CONTAINER_multihashmap_get (open_ports, h_port);
   if (NULL == op)
   {
     /* port closed, wait for it to possibly open */
     ch->state = CADET_CHANNEL_LOOSE;
-    (void) GNUNET_CONTAINER_multihashmap_put (loose_channels,
-                                              &ch->h_port,
-                                              ch,
-                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+    (void) GNUNET_CONTAINER_multihashmap_put (
+      loose_channels,
+      &ch->h_port,
+      ch,
+      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
     GNUNET_assert (NULL == ch->retry_control_task);
-    ch->retry_control_task
-      = GNUNET_SCHEDULER_add_delayed (TIMEOUT_CLOSED_PORT,
-                                      &timeout_closed_cb,
-                                      ch);
+    ch->retry_control_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT_CLOSED_PORT,
+                                                           &timeout_closed_cb,
+                                                           ch);
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Created loose incoming channel to port %s from peer %s\n",
          GNUNET_h2s (&ch->port),
@@ -795,14 +767,9 @@ GCCH_channel_incoming_new (struct CadetTunnel *t,
   }
   else
   {
-    GCCH_bind (ch,
-               op->c,
-               &op->port);
+    GCCH_bind (ch, op->c, &op->port);
   }
-  GNUNET_STATISTICS_update (stats,
-                            "# channels",
-                            1,
-                            GNUNET_NO);
+  GNUNET_STATISTICS_update (stats, "# channels", 1, GNUNET_NO);
   return ch;
 }
 
@@ -851,10 +818,7 @@ send_channel_data_ack (struct CadetChannel *ch)
        GCCH_2s (ch));
   if (NULL != ch->last_control_qe)
     GCT_send_cancel (ch->last_control_qe);
-  ch->last_control_qe = GCT_send (ch->t,
-                                  &msg.header,
-                                  &send_ack_cb,
-                                  ch);
+  ch->last_control_qe = GCT_send (ch->t, &msg.header, &send_ack_cb, ch);
 }
 
 
@@ -881,10 +845,7 @@ send_open_ack (void *cls)
   msg.port = ch->port;
   if (NULL != ch->last_control_qe)
     GCT_send_cancel (ch->last_control_qe);
-  ch->last_control_qe = GCT_send (ch->t,
-                                  &msg.header,
-                                  &send_ack_cb,
-                                  ch);
+  ch->last_control_qe = GCT_send (ch->t, &msg.header, &send_ack_cb, ch);
 }
 
 
@@ -897,8 +858,9 @@ send_open_ack (void *cls)
  * @param cti identifier of the connection that delivered the message
  */
 void
-GCCH_handle_duplicate_open (struct CadetChannel *ch,
-                            const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti)
+GCCH_handle_duplicate_open (
+  struct CadetChannel *ch,
+  const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti)
 {
   if (NULL == ch->dest)
   {
@@ -917,9 +879,7 @@ GCCH_handle_duplicate_open (struct CadetChannel *ch,
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Retransmitting CHANNEL_OPEN_ACK on %s\n",
        GCCH_2s (ch));
-  ch->retry_control_task
-    = GNUNET_SCHEDULER_add_now (&send_open_ack,
-                                ch);
+  ch->retry_control_task = GNUNET_SCHEDULER_add_now (&send_open_ack, ch);
 }
 
 
@@ -931,8 +891,7 @@ GCCH_handle_duplicate_open (struct CadetChannel *ch,
  *                 #GNUNET_NO to send to dest
  */
 static void
-send_ack_to_client (struct CadetChannel *ch,
-                    int to_owner)
+send_ack_to_client (struct CadetChannel *ch, int to_owner)
 {
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_CADET_LocalAck *ack;
@@ -946,8 +905,7 @@ send_ack_to_client (struct CadetChannel *ch,
     GNUNET_assert (GNUNET_YES == ch->destroy);
     return;
   }
-  env = GNUNET_MQ_msg (ack,
-                       GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK);
+  env = GNUNET_MQ_msg (ack, GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK);
   ack->ccn = ccc->ccn;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Sending CADET_LOCAL_ACK to %s (%s) at ccn %X (%u/%u pending)\n",
@@ -956,8 +914,7 @@ send_ack_to_client (struct CadetChannel *ch,
        ntohl (ack->ccn.channel_of_client),
        ch->pending_messages,
        ch->max_pending_messages);
-  GSC_send_to_client (ccc->c,
-                      env);
+  GSC_send_to_client (ccc->c, env);
 }
 
 
@@ -973,7 +930,7 @@ send_ack_to_client (struct CadetChannel *ch,
 void
 GCCH_bind (struct CadetChannel *ch,
            struct CadetClient *c,
-           const struct GNUNET_HashCode *port)
+           const struct GNUNET_HashCode *port)
 {
   uint32_t options;
   struct CadetChannelClient *cccd;
@@ -1000,9 +957,8 @@ GCCH_bind (struct CadetChannel *ch,
   cccd->ccn = GSC_bind (c,
                         ch,
                         (GNUNET_YES == ch->is_loopback)
-                        ? GCP_get (&my_full_id,
-                                   GNUNET_YES)
-                        : GCT_get_destination (ch->t),
+                          ? GCP_get (&my_full_id, GNUNET_YES)
+                          : GCT_get_destination (ch->t),
                         port,
                         options);
   GNUNET_assert (ntohl (cccd->ccn.channel_of_client) <
@@ -1011,24 +967,19 @@ GCCH_bind (struct CadetChannel *ch,
   if (GNUNET_YES == ch->is_loopback)
   {
     ch->state = CADET_CHANNEL_OPEN_SENT;
-    GCCH_handle_channel_open_ack (ch,
-                                  NULL,
-                                  port);
+    GCCH_handle_channel_open_ack (ch, NULL, port);
   }
   else
   {
     /* notify other peer that we accepted the connection */
     ch->state = CADET_CHANNEL_READY;
-    ch->retry_control_task
-      = GNUNET_SCHEDULER_add_now (&send_open_ack,
-                                  ch);
+    ch->retry_control_task = GNUNET_SCHEDULER_add_now (&send_open_ack, ch);
   }
   /* give client it's initial supply of ACKs */
   GNUNET_assert (ntohl (cccd->ccn.channel_of_client) <
                  GNUNET_CADET_LOCAL_CHANNEL_ID_CLI);
-  for (unsigned int i=0;i<ch->max_pending_messages;i++)
-    send_ack_to_client (ch,
-                        GNUNET_NO);
+  for (unsigned int i = 0; i < ch->max_pending_messages; i++)
+    send_ack_to_client (ch, GNUNET_NO);
 }
 
 
@@ -1048,9 +999,7 @@ signal_remote_destroy_cb (void *cls)
   /* Find which end is left... */
   ch->retry_control_task = NULL;
   ccc = (NULL != ch->owner) ? ch->owner : ch->dest;
-  GSC_handle_remote_channel_destroy (ccc->c,
-                                     ccc->ccn,
-                                     ch);
+  GSC_handle_remote_channel_destroy (ccc->c, ccc->ccn, ch);
   channel_destroy (ch);
 }
 
@@ -1073,16 +1022,14 @@ GCCH_channel_local_destroy (struct CadetChannel *ch,
        GSC_2s (c),
        GCCH_2s (ch));
   GNUNET_assert (NULL != c);
-  if ( (NULL != ch->owner) &&
-       (c == ch->owner->c) &&
-       (ccn.channel_of_client == ch->owner->ccn.channel_of_client) )
+  if ((NULL != ch->owner) && (c == ch->owner->c) &&
+      (ccn.channel_of_client == ch->owner->ccn.channel_of_client))
   {
     free_channel_client (ch->owner);
     ch->owner = NULL;
   }
-  else if ( (NULL != ch->dest) &&
-            (c == ch->dest->c) &&
-            (ccn.channel_of_client == ch->dest->ccn.channel_of_client) )
+  else if ((NULL != ch->dest) && (c == ch->dest->c) &&
+           (ccn.channel_of_client == ch->dest->ccn.channel_of_client))
   {
     free_channel_client (ch->dest);
     ch->dest = NULL;
@@ -1099,24 +1046,20 @@ GCCH_channel_local_destroy (struct CadetChannel *ch,
     channel_destroy (ch);
     return;
   }
-  if ( (NULL != ch->head_sent) &&
-       ( (NULL != ch->owner) ||
-         (NULL != ch->dest) ) )
+  if ((NULL != ch->head_sent) && ((NULL != ch->owner) || (NULL != ch->dest)))
   {
     /* Wait for other end to destroy us as well,
        and otherwise allow send queue to be transmitted first */
     ch->destroy = GNUNET_YES;
     return;
   }
-  if ( (GNUNET_YES == ch->is_loopback) &&
-       ( (NULL != ch->owner) ||
-         (NULL != ch->dest) ) )
+  if ((GNUNET_YES == ch->is_loopback) &&
+      ((NULL != ch->owner) || (NULL != ch->dest)))
   {
     if (NULL != ch->retry_control_task)
       GNUNET_SCHEDULER_cancel (ch->retry_control_task);
-    ch->retry_control_task
-      = GNUNET_SCHEDULER_add_now (&signal_remote_destroy_cb,
-                                  ch);
+    ch->retry_control_task =
+      GNUNET_SCHEDULER_add_now (&signal_remote_destroy_cb, ch);
     return;
   }
   if (GNUNET_NO == ch->is_loopback)
@@ -1131,8 +1074,7 @@ GCCH_channel_local_destroy (struct CadetChannel *ch,
     case CADET_CHANNEL_LOOSE:
       break;
     default:
-      GCT_send_channel_destroy (ch->t,
-                                ch->ctn);
+      GCT_send_channel_destroy (ch->t, ch->ctn);
     }
   }
   /* Nothing left to do, just finish destruction */
@@ -1150,9 +1092,10 @@ GCCH_channel_local_destroy (struct CadetChannel *ch,
  * @param port port number (needed to verify receiver knows the port)
  */
 void
-GCCH_handle_channel_open_ack (struct CadetChannel *ch,
-                              const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti,
-                              const struct GNUNET_HashCode *port)
+GCCH_handle_channel_open_ack (
+  struct CadetChannel *ch,
+  const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti,
+  const struct GNUNET_HashCode *port)
 {
   switch (ch->state)
   {
@@ -1171,8 +1114,7 @@ GCCH_handle_channel_open_ack (struct CadetChannel *ch,
       GNUNET_break_op (0);
       return;
     }
-    if (0 != GNUNET_memcmp (&ch->port,
-                     port))
+    if (0 != GNUNET_memcmp (&ch->port, port))
     {
       /* Other peer failed to provide the right port,
          refuse connection. */
@@ -1190,19 +1132,15 @@ GCCH_handle_channel_open_ack (struct CadetChannel *ch,
     ch->state = CADET_CHANNEL_READY;
     /* On first connect, send client as many ACKs as we allow messages
        to be buffered! */
-    for (unsigned int i=0;i<ch->max_pending_messages;i++)
-      send_ack_to_client (ch,
-                          GNUNET_YES);
+    for (unsigned int i = 0; i < ch->max_pending_messages; i++)
+      send_ack_to_client (ch, GNUNET_YES);
     break;
   case CADET_CHANNEL_READY:
     /* duplicate ACK, maybe we retried the CREATE. Ignore. */
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Received duplicate channel OPEN_ACK for %s\n",
          GCCH_2s (ch));
-    GNUNET_STATISTICS_update (stats,
-                              "# duplicate CREATE_ACKs",
-                              1,
-                              GNUNET_NO);
+    GNUNET_STATISTICS_update (stats, "# duplicate CREATE_ACKs", 1, GNUNET_NO);
     break;
   }
 }
@@ -1251,9 +1189,10 @@ is_before (void *cls,
  * @param msg message that was received
  */
 void
-GCCH_handle_channel_plaintext_data (struct CadetChannel *ch,
-                                    const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti,
-                                    const struct GNUNET_CADET_ChannelAppDataMessage *msg)
+GCCH_handle_channel_plaintext_data (
+  struct CadetChannel *ch,
+  const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti,
+  const struct GNUNET_CADET_ChannelAppDataMessage *msg)
 {
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_CADET_LocalData *ld;
@@ -1267,8 +1206,7 @@ GCCH_handle_channel_plaintext_data (struct CadetChannel *ch,
   uint32_t delta;
 
   GNUNET_assert (GNUNET_NO == ch->is_loopback);
-  if ( (NULL == ch->owner) &&
-       (NULL == ch->dest) )
+  if ((NULL == ch->owner) && (NULL == ch->dest))
   {
     /* This client is gone, but we still have messages to send to
        the other end (which is why @a ch is not yet dead).  However,
@@ -1278,8 +1216,7 @@ GCCH_handle_channel_plaintext_data (struct CadetChannel *ch,
          GCCH_2s (ch));
     /* send back DESTROY notification to stop further retransmissions! */
     if (GNUNET_YES == ch->destroy)
-      GCT_send_channel_destroy (ch->t,
-                                ch->ctn);
+      GCT_send_channel_destroy (ch->t, ch->ctn);
     return;
   }
   payload_size = ntohs (msg->header.size) - sizeof (*msg);
@@ -1287,9 +1224,7 @@ GCCH_handle_channel_plaintext_data (struct CadetChannel *ch,
                              payload_size,
                              GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA);
   ld->ccn = (NULL == ch->dest) ? ch->owner->ccn : ch->dest->ccn;
-  GNUNET_memcpy (&ld[1],
-                 &msg[1],
-                 payload_size);
+  GNUNET_memcpy (&ld[1], &msg[1], payload_size);
   ccc = (NULL != ch->owner) ? ch->owner : ch->dest;
   if (GNUNET_YES == ccc->client_ready)
   {
@@ -1299,13 +1234,12 @@ GCCH_handle_channel_plaintext_data (struct CadetChannel *ch,
      * - The channel is reliable and MID matches next expected MID
      * - The channel is unreliable and MID is before lowest seen MID
      */
-    if ( (GNUNET_YES == ch->out_of_order) ||
-         ((msg->mid.mid == ch->mid_recv.mid) &&
-          (GNUNET_YES == ch->reliable)) ||
-         ((GNUNET_NO == ch->reliable) &&
-          (ntohl (msg->mid.mid) >= ntohl (ch->mid_recv.mid)) &&
-          ((NULL == ccc->head_recv) ||
-           (ntohl (msg->mid.mid) < ntohl (ccc->head_recv->mid.mid)))) )
+    if ((GNUNET_YES == ch->out_of_order) ||
+        ((msg->mid.mid == ch->mid_recv.mid) && (GNUNET_YES == ch->reliable)) ||
+        ((GNUNET_NO == ch->reliable) &&
+         (ntohl (msg->mid.mid) >= ntohl (ch->mid_recv.mid)) &&
+         ((NULL == ccc->head_recv) ||
+          (ntohl (msg->mid.mid) < ntohl (ccc->head_recv->mid.mid)))))
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Giving %u bytes of payload with MID %u from %s to client %s\n",
@@ -1314,24 +1248,22 @@ GCCH_handle_channel_plaintext_data (struct CadetChannel *ch,
            GCCH_2s (ch),
            GSC_2s (ccc->c));
       ccc->client_ready = GNUNET_NO;
-      GSC_send_to_client (ccc->c,
-                          env);
+      GSC_send_to_client (ccc->c, env);
       if (GNUNET_NO == ch->out_of_order)
         ch->mid_recv.mid = htonl (1 + ntohl (msg->mid.mid));
       else
         ch->mid_recv.mid = htonl (1 + ntohl (ch->mid_recv.mid));
       ch->mid_futures >>= 1;
-      if ( (GNUNET_YES == ch->out_of_order) &&
-           (GNUNET_NO == ch->reliable) )
+      if ((GNUNET_YES == ch->out_of_order) && (GNUNET_NO == ch->reliable))
       {
-        /* possibly shift by more if we skipped messages */
-        uint64_t delta = htonl (msg->mid.mid) - 1 - ntohl (ch->mid_recv.mid);
-        
-        if (delta > 63)
-          ch->mid_futures = 0;
-        else
-          ch->mid_futures >>= delta;
-        ch->mid_recv.mid = htonl (1 + ntohl (msg->mid.mid));
+        /* possibly shift by more if we skipped messages */
+        uint64_t delta = htonl (msg->mid.mid) - 1 - ntohl (ch->mid_recv.mid);
+
+        if (delta > 63)
+          ch->mid_futures = 0;
+        else
+          ch->mid_futures >>= delta;
+        ch->mid_recv.mid = htonl (1 + ntohl (msg->mid.mid));
       }
       send_channel_data_ack (ch);
       return;
@@ -1344,8 +1276,8 @@ GCCH_handle_channel_plaintext_data (struct CadetChannel *ch,
     mid_min = ntohl (ch->mid_recv.mid);
     mid_max = mid_min + ch->max_pending_messages;
     mid_msg = ntohl (msg->mid.mid);
-    if ( ( (uint32_t) (mid_msg - mid_min) > ch->max_pending_messages) ||
-         ( (uint32_t) (mid_max - mid_msg) > ch->max_pending_messages) )
+    if (((uint32_t) (mid_msg - mid_min) > ch->max_pending_messages) ||
+        ((uint32_t) (mid_max - mid_msg) > ch->max_pending_messages))
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "%s at %u drops ancient or far-future message %u\n",
@@ -1373,10 +1305,7 @@ GCCH_handle_channel_plaintext_data (struct CadetChannel *ch,
              (unsigned int) payload_size,
              GCCH_2s (ch),
              ntohl (msg->mid.mid));
-        GNUNET_STATISTICS_update (stats,
-                                  "# duplicate DATA",
-                                  1,
-                                  GNUNET_NO);
+        GNUNET_STATISTICS_update (stats, "# duplicate DATA", 1, GNUNET_NO);
         GNUNET_MQ_discard (env);
         send_channel_data_ack (ch);
         return;
@@ -1398,8 +1327,7 @@ GCCH_handle_channel_plaintext_data (struct CadetChannel *ch,
      * We always send if possible in this case.
      * It is guaranteed that the queued MID < received MID
      **/
-    if ((NULL != ccc->head_recv) &&
-        (GNUNET_YES == ccc->client_ready))
+    if ((NULL != ccc->head_recv) && (GNUNET_YES == ccc->client_ready))
     {
       next_msg = ccc->head_recv;
       LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -1408,14 +1336,11 @@ GCCH_handle_channel_plaintext_data (struct CadetChannel *ch,
            GCCH_2s (ch),
            GSC_2s (ccc->c));
       ccc->client_ready = GNUNET_NO;
-      GSC_send_to_client (ccc->c,
-                          next_msg->env);
+      GSC_send_to_client (ccc->c, next_msg->env);
       ch->mid_recv.mid = htonl (1 + ntohl (next_msg->mid.mid));
       ch->mid_futures >>= 1;
       send_channel_data_ack (ch);
-      GNUNET_CONTAINER_DLL_remove (ccc->head_recv,
-                                   ccc->tail_recv,
-                                   next_msg);
+      GNUNET_CONTAINER_DLL_remove (ccc->head_recv, ccc->tail_recv, next_msg);
       ccc->num_recv--;
       /* Do not process duplicate MID */
       if (msg->mid.mid == next_msg->mid.mid) /* Duplicate */
@@ -1460,9 +1385,7 @@ GCCH_handle_channel_plaintext_data (struct CadetChannel *ch,
                                 GNUNET_NO);
       drop = ccc->head_recv;
       GNUNET_assert (NULL != drop);
-      GNUNET_CONTAINER_DLL_remove (ccc->head_recv,
-                                   ccc->tail_recv,
-                                   drop);
+      GNUNET_CONTAINER_DLL_remove (ccc->head_recv, ccc->tail_recv, drop);
       ccc->num_recv--;
       GNUNET_MQ_discard (drop->env);
       GNUNET_free (drop);
@@ -1493,13 +1416,8 @@ GCCH_handle_channel_plaintext_data (struct CadetChannel *ch,
          (unsigned int) payload_size,
          GCCH_2s (ch),
          ntohl (msg->mid.mid));
-    GNUNET_STATISTICS_update (stats,
-                              "# duplicate DATA",
-                              1,
-                              GNUNET_NO);
-    GNUNET_CONTAINER_DLL_remove (ccc->head_recv,
-                                 ccc->tail_recv,
-                                 com);
+    GNUNET_STATISTICS_update (stats, "# duplicate DATA", 1, GNUNET_NO);
+    GNUNET_CONTAINER_DLL_remove (ccc->head_recv, ccc->tail_recv, com);
     ccc->num_recv--;
     GNUNET_MQ_discard (com->env);
     GNUNET_free (com);
@@ -1508,9 +1426,7 @@ GCCH_handle_channel_plaintext_data (struct CadetChannel *ch,
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Queued %s payload of %u bytes on %s-%X(%p) (mid %u, need %u first)\n",
-       (GNUNET_YES == ccc->client_ready)
-       ? "out-of-order"
-       : "client-not-ready",
+       (GNUNET_YES == ccc->client_ready) ? "out-of-order" : "client-not-ready",
        (unsigned int) payload_size,
        GCCH_2s (ch),
        ntohl (ccc->ccn.channel_of_client),
@@ -1558,10 +1474,7 @@ retry_transmission (void *cls)
        "Retrying transmission on %s of message %u\n",
        GCCH_2s (ch),
        (unsigned int) ntohl (crm->data_message->mid.mid));
-  crm->qe = GCT_send (ch->t,
-                      &crm->data_message->header,
-                      &data_sent_cb,
-                      crm);
+  crm->qe = GCT_send (ch->t, &crm->data_message->header, &data_sent_cb, crm);
   GNUNET_assert (NULL == ch->retry_data_task);
 }
 
@@ -1579,9 +1492,7 @@ handle_matching_ack (struct CadetChannel *ch,
                      const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti,
                      struct CadetReliableMessage *crm)
 {
-  GNUNET_CONTAINER_DLL_remove (ch->head_sent,
-                               ch->tail_sent,
-                               crm);
+  GNUNET_CONTAINER_DLL_remove (ch->head_sent, ch->tail_sent, crm);
   ch->pending_messages--;
   GNUNET_assert (ch->pending_messages < ch->max_pending_messages);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -1594,23 +1505,19 @@ handle_matching_ack (struct CadetChannel *ch,
     GCT_send_cancel (crm->qe);
     crm->qe = NULL;
   }
-  if ( (1 == crm->num_transmissions) &&
-       (NULL != cti) )
+  if ((1 == crm->num_transmissions) && (NULL != cti))
   {
     GCC_ack_observed (cti);
-    if (0 == GNUNET_memcmp (cti,
-                     &crm->connection_taken))
+    if (0 == GNUNET_memcmp (cti, &crm->connection_taken))
     {
       GCC_latency_observed (cti,
-                            GNUNET_TIME_absolute_get_duration (crm->first_transmission_time));
+                            GNUNET_TIME_absolute_get_duration (
+                              crm->first_transmission_time));
     }
   }
   GNUNET_free (crm->data_message);
   GNUNET_free (crm);
-  send_ack_to_client (ch,
-                      (NULL == ch->owner)
-                      ? GNUNET_NO
-                      : GNUNET_YES);
+  send_ack_to_client (ch, (NULL == ch->owner) ? GNUNET_NO : GNUNET_YES);
 }
 
 
@@ -1623,9 +1530,10 @@ handle_matching_ack (struct CadetChannel *ch,
  * @param ack details about what was received
  */
 void
-GCCH_handle_channel_plaintext_data_ack (struct CadetChannel *ch,
-                                        const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti,
-                                        const struct GNUNET_CADET_ChannelDataAckMessage *ack)
+GCCH_handle_channel_plaintext_data_ack (
+  struct CadetChannel *ch,
+  const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti,
+  const struct GNUNET_CADET_ChannelDataAckMessage *ack)
 {
   struct CadetReliableMessage *crm;
   struct CadetReliableMessage *crmn;
@@ -1647,9 +1555,7 @@ GCCH_handle_channel_plaintext_data_ack (struct CadetChannel *ch,
   mid_base = ntohl (ack->mid.mid);
   mid_mask = GNUNET_htonll (ack->futures);
   found = GNUNET_NO;
-  for (crm = ch->head_sent;
-       NULL != crm;
-       crm = crmn)
+  for (crm = ch->head_sent; NULL != crm; crm = crmn)
   {
     crmn = crm->next;
     delta = (unsigned int) (ntohl (crm->data_message->mid.mid) - mid_base);
@@ -1661,9 +1567,7 @@ GCCH_handle_channel_plaintext_data_ack (struct CadetChannel *ch,
            (unsigned int) mid_base,
            ntohl (crm->data_message->mid.mid),
            GCCH_2s (ch));
-      handle_matching_ack (ch,
-                           cti,
-                           crm);
+      handle_matching_ack (ch, cti, crm);
       found = GNUNET_YES;
       continue;
     }
@@ -1681,9 +1585,7 @@ GCCH_handle_channel_plaintext_data_ack (struct CadetChannel *ch,
            "Got DATA_ACK with mask for %u on %s\n",
            ntohl (crm->data_message->mid.mid),
            GCCH_2s (ch));
-      handle_matching_ack (ch,
-                           cti,
-                           crm);
+      handle_matching_ack (ch, cti, crm);
       found = GNUNET_YES;
     }
   }
@@ -1694,10 +1596,7 @@ GCCH_handle_channel_plaintext_data_ack (struct CadetChannel *ch,
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Duplicate DATA_ACK on %s, ignoring\n",
          GCCH_2s (ch));
-    GNUNET_STATISTICS_update (stats,
-                              "# duplicate DATA_ACKs",
-                              1,
-                              GNUNET_NO);
+    GNUNET_STATISTICS_update (stats, "# duplicate DATA_ACKs", 1, GNUNET_NO);
     return;
   }
   if (NULL != ch->retry_data_task)
@@ -1705,12 +1604,10 @@ GCCH_handle_channel_plaintext_data_ack (struct CadetChannel *ch,
     GNUNET_SCHEDULER_cancel (ch->retry_data_task);
     ch->retry_data_task = NULL;
   }
-  if ( (NULL != ch->head_sent) &&
-       (NULL == ch->head_sent->qe) )
-    ch->retry_data_task
-      = GNUNET_SCHEDULER_add_at (ch->head_sent->next_retry,
-                                 &retry_transmission,
-                                 ch);
+  if ((NULL != ch->head_sent) && (NULL == ch->head_sent->qe))
+    ch->retry_data_task = GNUNET_SCHEDULER_add_at (ch->head_sent->next_retry,
+                                                   &retry_transmission,
+                                                   ch);
 }
 
 
@@ -1724,8 +1621,9 @@ GCCH_handle_channel_plaintext_data_ack (struct CadetChannel *ch,
  *            NULL if we are simulating receiving a destroy due to shutdown
  */
 void
-GCCH_handle_remote_destroy (struct CadetChannel *ch,
-                            const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti)
+GCCH_handle_remote_destroy (
+  struct CadetChannel *ch,
+  const struct GNUNET_CADET_ConnectionTunnelIdentifier *cti)
 {
   struct CadetChannelClient *ccc;
 
@@ -1740,8 +1638,7 @@ GCCH_handle_remote_destroy (struct CadetChannel *ch,
     return;
   }
   ccc = (NULL != ch->owner) ? ch->owner : ch->dest;
-  if ( (NULL != ccc) &&
-       (NULL != ccc->head_recv) )
+  if ((NULL != ccc) && (NULL != ccc->head_recv))
   {
     LOG (GNUNET_ERROR_TYPE_WARNING,
          "Lost end of transmission due to remote shutdown on %s\n",
@@ -1750,9 +1647,7 @@ GCCH_handle_remote_destroy (struct CadetChannel *ch,
   }
   ch->destroy = GNUNET_YES;
   if (NULL != ccc)
-    GSC_handle_remote_channel_destroy (ccc->c,
-                                       ccc->ccn,
-                                       ch);
+    GSC_handle_remote_channel_destroy (ccc->c, ccc->ccn, ch);
   channel_destroy (ch);
 }
 
@@ -1770,8 +1665,7 @@ cmp_crm_by_next_retry (void *cls,
                        struct CadetReliableMessage *crm1,
                        struct CadetReliableMessage *crm2)
 {
-  if (crm1->next_retry.abs_value_us <
-      crm2->next_retry.abs_value_us)
+  if (crm1->next_retry.abs_value_us < crm2->next_retry.abs_value_us)
     return GNUNET_YES;
   return GNUNET_NO;
 }
@@ -1797,18 +1691,13 @@ data_sent_cb (void *cls,
   GNUNET_assert (GNUNET_NO == ch->is_loopback);
   GNUNET_assert (NULL != crm->qe);
   crm->qe = NULL;
-  GNUNET_CONTAINER_DLL_remove (ch->head_sent,
-                               ch->tail_sent,
-                               crm);
+  GNUNET_CONTAINER_DLL_remove (ch->head_sent, ch->tail_sent, crm);
   if (GNUNET_NO == ch->reliable)
   {
     GNUNET_free (crm->data_message);
     GNUNET_free (crm);
     ch->pending_messages--;
-    send_ack_to_client (ch,
-                        (NULL == ch->owner)
-                        ? GNUNET_NO
-                        : GNUNET_YES);
+    send_ack_to_client (ch, (NULL == ch->owner) ? GNUNET_NO : GNUNET_YES);
     return;
   }
   if (NULL == cid)
@@ -1828,8 +1717,7 @@ data_sent_cb (void *cls,
       GCC_ack_expected (cid);
     }
   }
-  if ( (0 == crm->retry_delay.rel_value_us) &&
-       (NULL != cid) )
+  if ((0 == crm->retry_delay.rel_value_us) && (NULL != cid))
   {
     struct CadetConnection *cc = GCC_lookup (cid);
 
@@ -1839,8 +1727,7 @@ data_sent_cb (void *cls,
       crm->retry_delay = ch->retry_time;
   }
   crm->retry_delay = GNUNET_TIME_STD_BACKOFF (crm->retry_delay);
-  crm->retry_delay = GNUNET_TIME_relative_max (crm->retry_delay,
-                                               MIN_RTT_DELAY);
+  crm->retry_delay = GNUNET_TIME_relative_max (crm->retry_delay, MIN_RTT_DELAY);
   crm->next_retry = GNUNET_TIME_relative_to_absolute (crm->retry_delay);
 
   GNUNET_CONTAINER_DLL_insert_sorted (struct CadetReliableMessage,
@@ -1853,16 +1740,16 @@ data_sent_cb (void *cls,
        "Message %u sent, next transmission on %s in %s\n",
        (unsigned int) ntohl (crm->data_message->mid.mid),
        GCCH_2s (ch),
-       GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (ch->head_sent->next_retry),
+       GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (
+                                                 ch->head_sent->next_retry),
                                                GNUNET_YES));
   if (NULL == ch->head_sent->qe)
   {
     if (NULL != ch->retry_data_task)
       GNUNET_SCHEDULER_cancel (ch->retry_data_task);
-    ch->retry_data_task
-      = GNUNET_SCHEDULER_add_at (ch->head_sent->next_retry,
-                                 &retry_transmission,
-                                 ch);
+    ch->retry_data_task = GNUNET_SCHEDULER_add_at (ch->head_sent->next_retry,
+                                                   &retry_transmission,
+                                                   ch);
   }
 }
 
@@ -1908,19 +1795,16 @@ GCCH_handle_local_data (struct CadetChannel *ch,
     struct GNUNET_CADET_LocalData *ld;
     int ack_to_owner;
 
-    env = GNUNET_MQ_msg_extra (ld,
-                               buf_len,
-                               GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA);
-    if ( (NULL != ch->owner) &&
-         (sender_ccn.channel_of_client ==
-          ch->owner->ccn.channel_of_client) )
+    env =
+      GNUNET_MQ_msg_extra (ld, buf_len, GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA);
+    if ((NULL != ch->owner) &&
+        (sender_ccn.channel_of_client == ch->owner->ccn.channel_of_client))
     {
       receiver = ch->dest;
       ack_to_owner = GNUNET_YES;
     }
-    else if ( (NULL != ch->dest) &&
-              (sender_ccn.channel_of_client ==
-               ch->dest->ccn.channel_of_client) )
+    else if ((NULL != ch->dest) &&
+             (sender_ccn.channel_of_client == ch->dest->ccn.channel_of_client))
     {
       receiver = ch->owner;
       ack_to_owner = GNUNET_NO;
@@ -1932,16 +1816,12 @@ GCCH_handle_local_data (struct CadetChannel *ch,
     }
     GNUNET_assert (NULL != receiver);
     ld->ccn = receiver->ccn;
-    GNUNET_memcpy (&ld[1],
-                   buf,
-                   buf_len);
+    GNUNET_memcpy (&ld[1], buf, buf_len);
     if (GNUNET_YES == receiver->client_ready)
     {
       ch->pending_messages--;
-      GSC_send_to_client (receiver->c,
-                          env);
-      send_ack_to_client (ch,
-                          ack_to_owner);
+      GSC_send_to_client (receiver->c, env);
+      send_ack_to_client (ch, ack_to_owner);
     }
     else
     {
@@ -1960,19 +1840,17 @@ GCCH_handle_local_data (struct CadetChannel *ch,
   /* Everything is correct, send the message. */
   crm = GNUNET_malloc (sizeof (*crm));
   crm->ch = ch;
-  crm->data_message = GNUNET_malloc (sizeof (struct GNUNET_CADET_ChannelAppDataMessage)
-                                     + buf_len);
-  crm->data_message->header.size = htons (sizeof (struct GNUNET_CADET_ChannelAppDataMessage) + buf_len);
-  crm->data_message->header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA);
+  crm->data_message = GNUNET_malloc (
+    sizeof (struct GNUNET_CADET_ChannelAppDataMessage) + buf_len);
+  crm->data_message->header.size =
+    htons (sizeof (struct GNUNET_CADET_ChannelAppDataMessage) + buf_len);
+  crm->data_message->header.type =
+    htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA);
   ch->mid_send.mid = htonl (ntohl (ch->mid_send.mid) + 1);
   crm->data_message->mid = ch->mid_send;
   crm->data_message->ctn = ch->ctn;
-  GNUNET_memcpy (&crm->data_message[1],
-                 buf,
-                 buf_len);
-  GNUNET_CONTAINER_DLL_insert_tail (ch->head_sent,
-                                    ch->tail_sent,
-                                    crm);
+  GNUNET_memcpy (&crm->data_message[1], buf, buf_len);
+  GNUNET_CONTAINER_DLL_insert_tail (ch->head_sent, ch->tail_sent, crm);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Sending message %u from local client to %s with %u bytes\n",
        ntohl (crm->data_message->mid.mid),
@@ -1983,10 +1861,7 @@ GCCH_handle_local_data (struct CadetChannel *ch,
     GNUNET_SCHEDULER_cancel (ch->retry_data_task);
     ch->retry_data_task = NULL;
   }
-  crm->qe = GCT_send (ch->t,
-                      &crm->data_message->header,
-                      &data_sent_cb,
-                      crm);
+  crm->qe = GCT_send (ch->t, &crm->data_message->header, &data_sent_cb, crm);
   GNUNET_assert (NULL == ch->retry_data_task);
   return GNUNET_OK;
 }
@@ -2006,11 +1881,11 @@ GCCH_handle_local_ack (struct CadetChannel *ch,
   struct CadetChannelClient *ccc;
   struct CadetOutOfOrderMessage *com;
 
-  if ( (NULL != ch->owner) &&
-       (ch->owner->ccn.channel_of_client == client_ccn.channel_of_client) )
+  if ((NULL != ch->owner) &&
+      (ch->owner->ccn.channel_of_client == client_ccn.channel_of_client))
     ccc = ch->owner;
-  else if ( (NULL != ch->dest) &&
-            (ch->dest->ccn.channel_of_client == client_ccn.channel_of_client) )
+  else if ((NULL != ch->dest) &&
+           (ch->dest->ccn.channel_of_client == client_ccn.channel_of_client))
     ccc = ch->dest;
   else
     GNUNET_assert (0);
@@ -2032,35 +1907,28 @@ GCCH_handle_local_ack (struct CadetChannel *ch,
     int to_owner;
 
     /* Messages are always in-order, just send */
-    GNUNET_CONTAINER_DLL_remove (ccc->head_recv,
-                                 ccc->tail_recv,
-                                 com);
+    GNUNET_CONTAINER_DLL_remove (ccc->head_recv, ccc->tail_recv, com);
     ccc->num_recv--;
-    GSC_send_to_client (ccc->c,
-                        com->env);
+    GSC_send_to_client (ccc->c, com->env);
     /* Notify sender that we can receive more */
-    if ( (NULL != ch->owner) &&
-         (ccc->ccn.channel_of_client ==
-          ch->owner->ccn.channel_of_client) )
+    if ((NULL != ch->owner) &&
+        (ccc->ccn.channel_of_client == ch->owner->ccn.channel_of_client))
     {
       to_owner = GNUNET_NO;
     }
     else
     {
-      GNUNET_assert ( (NULL != ch->dest) &&
-                      (ccc->ccn.channel_of_client ==
-                       ch->dest->ccn.channel_of_client) );
+      GNUNET_assert ((NULL != ch->dest) && (ccc->ccn.channel_of_client ==
+                                            ch->dest->ccn.channel_of_client));
       to_owner = GNUNET_YES;
     }
-    send_ack_to_client (ch,
-                        to_owner);
+    send_ack_to_client (ch, to_owner);
     GNUNET_free (com);
     return;
   }
 
-  if ( (com->mid.mid != ch->mid_recv.mid) &&
-       (GNUNET_NO == ch->out_of_order) &&
-       (GNUNET_YES == ch->reliable) )
+  if ((com->mid.mid != ch->mid_recv.mid) && (GNUNET_NO == ch->out_of_order) &&
+      (GNUNET_YES == ch->reliable))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Got LOCAL_ACK, %s-%X ready to receive more data (but next one is out-of-order %u vs. %u)!\n",
@@ -2079,9 +1947,7 @@ GCCH_handle_local_ack (struct CadetChannel *ch,
        GCCH_2s (ch));
 
   /* all good, pass next message to client */
-  GNUNET_CONTAINER_DLL_remove (ccc->head_recv,
-                               ccc->tail_recv,
-                               com);
+  GNUNET_CONTAINER_DLL_remove (ccc->head_recv, ccc->tail_recv, com);
   ccc->num_recv--;
   /* FIXME: if unreliable, this is not aggressive
      enough, as it would be OK to have lost some! */
@@ -2089,21 +1955,20 @@ GCCH_handle_local_ack (struct CadetChannel *ch,
   ch->mid_recv.mid = htonl (1 + ntohl (com->mid.mid));
   ch->mid_futures >>= 1; /* equivalent to division by 2 */
   ccc->client_ready = GNUNET_NO;
-  GSC_send_to_client (ccc->c,
-                      com->env);
+  GSC_send_to_client (ccc->c, com->env);
   GNUNET_free (com);
   send_channel_data_ack (ch);
   if (NULL != ccc->head_recv)
     return;
   if (GNUNET_NO == ch->destroy)
     return;
-  GCT_send_channel_destroy (ch->t,
-                            ch->ctn);
+  GCT_send_channel_destroy (ch->t, ch->ctn);
   channel_destroy (ch);
 }
 
 
-#define LOG2(level, ...) GNUNET_log_from_nocheck(level,"cadet-chn",__VA_ARGS__)
+#define LOG2(level, ...) \
+  GNUNET_log_from_nocheck (level, "cadet-chn", __VA_ARGS__)
 
 
 /**
@@ -2113,15 +1978,16 @@ GCCH_handle_local_ack (struct CadetChannel *ch,
  * @param level Debug level to use.
  */
 void
-GCCH_debug (struct CadetChannel *ch,
-            enum GNUNET_ErrorType level)
+GCCH_debug (struct CadetChannel *ch, enum GNUNET_ErrorType level)
 {
-#if !defined(GNUNET_CULL_LOGGING)
+#if ! defined(GNUNET_CULL_LOGGING)
   int do_log;
 
   do_log = GNUNET_get_log_call_status (level & (~GNUNET_ERROR_TYPE_BULK),
                                        "cadet-chn",
-                                       __FILE__, __FUNCTION__, __LINE__);
+                                       __FILE__,
+                                       __FUNCTION__,
+                                       __LINE__);
   if (0 == do_log)
     return;
 
@@ -2130,11 +1996,7 @@ GCCH_debug (struct CadetChannel *ch,
     LOG2 (level, "CHN *** DEBUG NULL CHANNEL ***\n");
     return;
   }
-  LOG2 (level,
-        "CHN %s:%X (%p)\n",
-        GCT_2s (ch->t),
-        ch->ctn,
-        ch);
+  LOG2 (level, "CHN %s:%X (%p)\n", GCT_2s (ch->t), ch->ctn, ch);
   if (NULL != ch->owner)
   {
     LOG2 (level,
@@ -2160,5 +2022,4 @@ GCCH_debug (struct CadetChannel *ch,
 }
 
 
-
 /* end of gnunet-service-cadet-new_channel.c */
diff --git a/src/cadet/gnunet-service-cadet_connection.c b/src/cadet/gnunet-service-cadet_connection.c
index 7214dad97..8849e563f 100644
--- a/src/cadet/gnunet-service-cadet_connection.c
+++ b/src/cadet/gnunet-service-cadet_connection.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/>.
 
@@ -35,14 +35,15 @@
 #include "cadet_protocol.h"
 
 
-#define LOG(level, ...) GNUNET_log_from(level,"cadet-con",__VA_ARGS__)
+#define LOG(level, ...) GNUNET_log_from (level, "cadet-con", __VA_ARGS__)
 
 
 /**
  * How long do we wait initially before retransmitting the KX?
  * TODO: replace by 2 RTT if/once we have connection-level RTT data!
  */
-#define INITIAL_CONNECTION_CREATE_RETRY_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 200)
+#define INITIAL_CONNECTION_CREATE_RETRY_DELAY \
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 200)
 
 
 /**
@@ -174,7 +175,6 @@ struct CadetConnection
    * Are we ready to transmit via @e mq_man right now?
    */
   int mqm_ready;
-
 };
 
 
@@ -208,18 +208,16 @@ update_state (struct CadetConnection *cc,
   int old_ready;
   int new_ready;
 
-  if ( (new_state == cc->state) &&
-       (new_mqm_ready == cc->mqm_ready) )
+  if ((new_state == cc->state) && (new_mqm_ready == cc->mqm_ready))
     return; /* no change, nothing to do */
-  old_ready = ( (CADET_CONNECTION_READY == cc->state) &&
-                (GNUNET_YES == cc->mqm_ready) );
-  new_ready = ( (CADET_CONNECTION_READY == new_state) &&
-                (GNUNET_YES == new_mqm_ready) );
+  old_ready =
+    ((CADET_CONNECTION_READY == cc->state) && (GNUNET_YES == cc->mqm_ready));
+  new_ready =
+    ((CADET_CONNECTION_READY == new_state) && (GNUNET_YES == new_mqm_ready));
   cc->state = new_state;
   cc->mqm_ready = new_mqm_ready;
   if (old_ready != new_ready)
-    cc->ready_cb (cc->ready_cb_cls,
-                  new_ready);
+    cc->ready_cb (cc->ready_cb_cls, new_ready);
 }
 
 
@@ -232,13 +230,10 @@ update_state (struct CadetConnection *cc,
 static void
 GCC_destroy (struct CadetConnection *cc)
 {
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Destroying %s\n",
-       GCC_2s (cc));
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Destroying %s\n", GCC_2s (cc));
   if (NULL != cc->mq_man)
   {
-    GCP_request_mq_cancel (cc->mq_man,
-                           NULL);
+    GCP_request_mq_cancel (cc->mq_man, NULL);
     cc->mq_man = NULL;
   }
   if (NULL != cc->task)
@@ -251,22 +246,19 @@ GCC_destroy (struct CadetConnection *cc)
     GCT_send_cancel (cc->keepalive_qe);
     cc->keepalive_qe = NULL;
   }
-  GCPP_del_connection (cc->path,
-                       cc->off,
-                       cc);
-  for (unsigned int i=0;i<cc->off;i++)
-    GCP_remove_connection (GCPP_get_peer_at_offset (cc->path,
-                                                    i),
-                           cc);
-  GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multishortmap_remove (connections,
-                                                        &GCC_get_id (cc)->connection_of_tunnel,
-                                                        cc));
+  GCPP_del_connection (cc->path, cc->off, cc);
+  for (unsigned int i = 0; i < cc->off; i++)
+    GCP_remove_connection (GCPP_get_peer_at_offset (cc->path, i), cc);
+  GNUNET_assert (
+    GNUNET_YES ==
+    GNUNET_CONTAINER_multishortmap_remove (connections,
+                                           &GCC_get_id (cc)
+                                              ->connection_of_tunnel,
+                                           cc));
   GNUNET_free (cc);
 }
 
 
-
 /**
  * Destroy a connection, called when the CORE layer is already done
  * (i.e. has received a BROKEN message), but if we still have to
@@ -298,18 +290,16 @@ void
 GCC_destroy_without_tunnel (struct CadetConnection *cc)
 {
   cc->ct = NULL;
-  if ( (CADET_CONNECTION_SENDING_CREATE != cc->state) &&
-       (NULL != cc->mq_man) )
+  if ((CADET_CONNECTION_SENDING_CREATE != cc->state) && (NULL != cc->mq_man))
   {
     struct GNUNET_MQ_Envelope *env;
     struct GNUNET_CADET_ConnectionDestroyMessage *destroy_msg;
 
     /* Need to notify next hop that we are down. */
-    env = GNUNET_MQ_msg (destroy_msg,
-                         GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY);
+    env =
+      GNUNET_MQ_msg (destroy_msg, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY);
     destroy_msg->cid = cc->cid;
-    GCP_request_mq_cancel (cc->mq_man,
-                           env);
+    GCP_request_mq_cancel (cc->mq_man, env);
     cc->mq_man = NULL;
   }
   GCC_destroy (cc);
@@ -367,11 +357,9 @@ keepalive_done (void *cls,
   struct CadetConnection *cc = cls;
 
   cc->keepalive_qe = NULL;
-  if ( (GNUNET_YES == cc->mqm_ready) &&
-       (NULL == cc->task) )
-    cc->task = GNUNET_SCHEDULER_add_delayed (keepalive_period,
-                                             &send_keepalive,
-                                             cc);
+  if ((GNUNET_YES == cc->mqm_ready) && (NULL == cc->task))
+    cc->task =
+      GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc);
 }
 
 
@@ -391,9 +379,8 @@ send_keepalive (void *cls)
   if (CADET_TUNNEL_KEY_OK != GCT_get_estate (cc->ct->t))
   {
     /* Tunnel not yet ready, wait with keepalives... */
-    cc->task = GNUNET_SCHEDULER_add_delayed (keepalive_period,
-                                             &send_keepalive,
-                                             cc);
+    cc->task =
+      GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc);
     return;
   }
   GNUNET_assert (NULL != cc->ct);
@@ -403,18 +390,11 @@ send_keepalive (void *cls)
        "Sending KEEPALIVE on behalf of %s via %s\n",
        GCC_2s (cc),
        GCT_2s (cc->ct->t));
-  GNUNET_STATISTICS_update (stats,
-                            "# keepalives sent",
-                            1,
-                            GNUNET_NO);
+  GNUNET_STATISTICS_update (stats, "# keepalives sent", 1, GNUNET_NO);
   msg.size = htons (sizeof (msg));
   msg.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_KEEPALIVE);
 
-  cc->keepalive_qe
-    = GCT_send (cc->ct->t,
-                &msg,
-                &keepalive_done,
-                cc);
+  cc->keepalive_qe = GCT_send (cc->ct->t, &msg, &keepalive_done, cc);
 }
 
 
@@ -475,10 +455,7 @@ GCC_latency_observed (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid,
   cc = GCC_lookup (cid);
   if (NULL == cc)
     return; /* whopise, connection alredy down? */
-  GNUNET_STATISTICS_update (stats,
-                            "# latencies observed",
-                            1,
-                            GNUNET_NO);
+  GNUNET_STATISTICS_update (stats, "# latencies observed", 1, GNUNET_NO);
   cc->latency_datapoints++;
   if (cc->latency_datapoints >= 7)
     weight = 7.0;
@@ -487,7 +464,8 @@ GCC_latency_observed (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid,
   /* Compute weighted average, giving at MOST weight 7 to the
      existing values, or less if that value is based on fewer than 7
      measurements. */
-  result = (weight * cc->metrics.aged_latency.rel_value_us) + 1.0 * latency.rel_value_us;
+  result = (weight * cc->metrics.aged_latency.rel_value_us) +
+           1.0 * latency.rel_value_us;
   result /= (weight + 1.0);
   cc->metrics.aged_latency.rel_value_us = (uint64_t) result;
 }
@@ -516,15 +494,11 @@ GCC_handle_connection_create_ack (struct CadetConnection *cc)
     cc->task = NULL;
   }
   cc->metrics.age = GNUNET_TIME_absolute_get ();
-  update_state (cc,
-                CADET_CONNECTION_READY,
-                cc->mqm_ready);
-  if ( (NULL == cc->keepalive_qe) &&
-       (GNUNET_YES == cc->mqm_ready) &&
-       (NULL == cc->task) )
-    cc->task = GNUNET_SCHEDULER_add_delayed (keepalive_period,
-                                             &send_keepalive,
-                                             cc);
+  update_state (cc, CADET_CONNECTION_READY, cc->mqm_ready);
+  if ((NULL == cc->keepalive_qe) && (GNUNET_YES == cc->mqm_ready) &&
+      (NULL == cc->task))
+    cc->task =
+      GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc);
 }
 
 
@@ -552,8 +526,7 @@ GCC_handle_kx (struct CadetConnection *cc,
          GCC_2s (cc));
     GCC_handle_connection_create_ack (cc);
   }
-  GCT_handle_kx (cc->ct,
-                 msg);
+  GCT_handle_kx (cc->ct, msg);
 }
 
 
@@ -581,8 +554,7 @@ GCC_handle_kx_auth (struct CadetConnection *cc,
          GCC_2s (cc));
     GCC_handle_connection_create_ack (cc);
   }
-  GCT_handle_kx_auth (cc->ct,
-                      msg);
+  GCT_handle_kx_auth (cc->ct, msg);
 }
 
 
@@ -606,8 +578,7 @@ GCC_handle_encrypted (struct CadetConnection *cc,
     GCC_handle_connection_create_ack (cc);
   }
   cc->metrics.last_use = GNUNET_TIME_absolute_get ();
-  GCT_handle_encrypted (cc->ct,
-                        msg);
+  GCT_handle_encrypted (cc->ct, msg);
 }
 
 
@@ -627,17 +598,17 @@ send_create (void *cls)
 
   cc->task = NULL;
   GNUNET_assert (GNUNET_YES == cc->mqm_ready);
-  env = GNUNET_MQ_msg_extra (create_msg,
-                             (2 + cc->off) * sizeof (struct GNUNET_PeerIdentity),
-                             GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE);
-  //TODO This will be removed in a major release, because this will be a protocol breaking change. We shift here to be compatible with GNUNET_CADET_OPTION_RELIABLE that was removed, and to already use the newly introduced options.
-  create_msg->options = GNUNET_MQ_PREF_RELIABLE >> 10;
+  env =
+    GNUNET_MQ_msg_extra (create_msg,
+                         (2 + cc->off) * sizeof (struct GNUNET_PeerIdentity),
+                         GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE);
+  //TODO This will be removed in a major release, because this will be a protocol breaking change. We set the deprecated 'reliable' bit here that was removed.
+  create_msg->options = 2;
   create_msg->cid = cc->cid;
   pids = (struct GNUNET_PeerIdentity *) &create_msg[1];
   pids[0] = my_full_id;
-  for (unsigned int i=0;i<=cc->off;i++)
-    pids[i + 1] = *GCP_get_id (GCPP_get_peer_at_offset (cc->path,
-                                                        i));
+  for (unsigned int i = 0; i <= cc->off; i++)
+    pids[i + 1] = *GCP_get_id (GCPP_get_peer_at_offset (cc->path, i));
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Sending CADET_CONNECTION_CREATE message for %s with %u hops\n",
        GCC_2s (cc),
@@ -645,11 +616,8 @@ send_create (void *cls)
   cc->env = env;
   cc->retry_delay = GNUNET_TIME_STD_BACKOFF (cc->retry_delay);
   cc->create_at = GNUNET_TIME_relative_to_absolute (cc->retry_delay);
-  update_state (cc,
-                CADET_CONNECTION_SENT,
-                GNUNET_NO);
-  GCP_send (cc->mq_man,
-            env);
+  update_state (cc, CADET_CONNECTION_SENT, GNUNET_NO);
+  GCP_send (cc->mq_man, env);
 }
 
 
@@ -670,22 +638,18 @@ send_create_ack (void *cls)
        "Sending CONNECTION_CREATE_ACK message for %s\n",
        GCC_2s (cc));
   GNUNET_assert (GNUNET_YES == cc->mqm_ready);
-  env = GNUNET_MQ_msg (ack_msg,
-                       GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK);
+  env =
+    GNUNET_MQ_msg (ack_msg, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK);
   ack_msg->cid = cc->cid;
   cc->env = env;
   cc->retry_delay = GNUNET_TIME_STD_BACKOFF (cc->retry_delay);
   cc->create_ack_at = GNUNET_TIME_relative_to_absolute (cc->retry_delay);
   if (CADET_CONNECTION_CREATE_RECEIVED == cc->state)
-    update_state (cc,
-                  CADET_CONNECTION_READY,
-                  GNUNET_NO);
+    update_state (cc, CADET_CONNECTION_READY, GNUNET_NO);
   if (CADET_CONNECTION_READY == cc->state)
-    cc->task = GNUNET_SCHEDULER_add_delayed (keepalive_period,
-                                             &send_keepalive,
-                                             cc);
-  GCP_send (cc->mq_man,
-            env);
+    cc->task =
+      GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc);
+  GCP_send (cc->mq_man, env);
 }
 
 
@@ -707,14 +671,11 @@ GCC_handle_duplicate_create (struct CadetConnection *cc)
          (GNUNET_YES == cc->mqm_ready) ? "MQM ready" : "MQM busy");
     /* Revert back to the state of having only received the 'CREATE',
        and immediately proceed to send the CREATE_ACK. */
-    update_state (cc,
-                  CADET_CONNECTION_CREATE_RECEIVED,
-                  cc->mqm_ready);
+    update_state (cc, CADET_CONNECTION_CREATE_RECEIVED, cc->mqm_ready);
     if (NULL != cc->task)
       GNUNET_SCHEDULER_cancel (cc->task);
-    cc->task = GNUNET_SCHEDULER_add_at (cc->create_ack_at,
-                                        &send_create_ack,
-                                        cc);
+    cc->task =
+      GNUNET_SCHEDULER_add_at (cc->create_ack_at, &send_create_ack, cc);
   }
   else
   {
@@ -739,20 +700,15 @@ GCC_handle_duplicate_create (struct CadetConnection *cc)
  *                                 and the last envelope was discarded
  */
 static void
-manage_first_hop_mq (void *cls,
-                     int available)
+manage_first_hop_mq (void *cls, int available)
 {
   struct CadetConnection *cc = cls;
 
   if (GNUNET_YES != available)
   {
     /* Connection is down, for now... */
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Core MQ for %s went down\n",
-         GCC_2s (cc));
-    update_state (cc,
-                  CADET_CONNECTION_NEW,
-                  GNUNET_NO);
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Core MQ for %s went down\n", GCC_2s (cc));
+    update_state (cc, CADET_CONNECTION_NEW, GNUNET_NO);
     cc->retry_delay = INITIAL_CONNECTION_CREATE_RETRY_DELAY;
     if (NULL != cc->task)
     {
@@ -762,9 +718,7 @@ manage_first_hop_mq (void *cls,
     return;
   }
 
-  update_state (cc,
-                cc->state,
-                GNUNET_YES);
+  update_state (cc, cc->state, GNUNET_YES);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Core MQ for %s became available in state %d\n",
        GCC_2s (cc),
@@ -773,9 +727,7 @@ manage_first_hop_mq (void *cls,
   {
   case CADET_CONNECTION_NEW:
     /* Transmit immediately */
-    cc->task = GNUNET_SCHEDULER_add_at (cc->create_at,
-                                        &send_create,
-                                        cc);
+    cc->task = GNUNET_SCHEDULER_add_at (cc->create_at, &send_create, cc);
     break;
   case CADET_CONNECTION_SENDING_CREATE:
     /* Should not be possible to be called in this state. */
@@ -783,30 +735,25 @@ manage_first_hop_mq (void *cls,
     break;
   case CADET_CONNECTION_SENT:
     /* Retry a bit later... */
-    cc->task = GNUNET_SCHEDULER_add_at (cc->create_at,
-                                        &send_create,
-                                        cc);
+    cc->task = GNUNET_SCHEDULER_add_at (cc->create_at, &send_create, cc);
     break;
   case CADET_CONNECTION_CREATE_RECEIVED:
     /* We got the 'CREATE' (incoming connection), should send the CREATE_ACK */
     cc->metrics.age = GNUNET_TIME_absolute_get ();
-    cc->task = GNUNET_SCHEDULER_add_at (cc->create_ack_at,
-                                        &send_create_ack,
-                                        cc);
+    cc->task =
+      GNUNET_SCHEDULER_add_at (cc->create_ack_at, &send_create_ack, cc);
     break;
   case CADET_CONNECTION_READY:
-    if ( (NULL == cc->keepalive_qe) &&
-         (GNUNET_YES == cc->mqm_ready) &&
-         (NULL == cc->task) )
+    if ((NULL == cc->keepalive_qe) && (GNUNET_YES == cc->mqm_ready) &&
+        (NULL == cc->task))
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Scheduling keepalive for %s in %s\n",
            GCC_2s (cc),
            GNUNET_STRINGS_relative_time_to_string (keepalive_period,
                                                    GNUNET_YES));
-      cc->task = GNUNET_SCHEDULER_add_delayed (keepalive_period,
-                                               &send_keepalive,
-                                               cc);
+      cc->task =
+        GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc);
     }
     break;
   }
@@ -844,13 +791,14 @@ connection_create (struct CadetPeer *destination,
   cc->state = init_state;
   cc->ct = ct;
   cc->cid = *cid;
-  cc->retry_delay = GNUNET_TIME_relative_multiply (INITIAL_CONNECTION_CREATE_RETRY_DELAY,
-                                                   off);
+  cc->retry_delay =
+    GNUNET_TIME_relative_multiply (INITIAL_CONNECTION_CREATE_RETRY_DELAY, off);
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multishortmap_put (connections,
-                                                     &GCC_get_id (cc)->connection_of_tunnel,
-                                                     cc,
-                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+                 GNUNET_CONTAINER_multishortmap_put (
+                   connections,
+                   &GCC_get_id (cc)->connection_of_tunnel,
+                   cc,
+                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   cc->ready_cb = ready_cb;
   cc->ready_cb_cls = ready_cb_cls;
   cc->path = path;
@@ -860,18 +808,11 @@ connection_create (struct CadetPeer *destination,
        GCC_2s (cc),
        GCPP_2s (path),
        off);
-  GCPP_add_connection (path,
-                       off,
-                       cc);
-  for (unsigned int i=0;i<off;i++)
-    GCP_add_connection (GCPP_get_peer_at_offset (path,
-                                                 i),
-                        cc);
-  first_hop = GCPP_get_peer_at_offset (path,
-                                       0);
-  cc->mq_man = GCP_request_mq (first_hop,
-                               &manage_first_hop_mq,
-                               cc);
+  GCPP_add_connection (path, off, cc);
+  for (unsigned int i = 0; i < off; i++)
+    GCP_add_connection (GCPP_get_peer_at_offset (path, i), cc);
+  first_hop = GCPP_get_peer_at_offset (path, 0);
+  cc->mq_man = GCP_request_mq (first_hop, &manage_first_hop_mq, cc);
   return cc;
 }
 
@@ -900,18 +841,14 @@ GCC_create_inbound (struct CadetPeer *destination,
   struct CadetConnection *cc;
   unsigned int off;
 
-  off = GCPP_find_peer (path,
-                        destination);
+  off = GCPP_find_peer (path, destination);
   GNUNET_assert (UINT_MAX != off);
-  cc = GCPP_get_connection (path,
-                            destination,
-                            off);
+  cc = GCPP_get_connection (path, destination, off);
   if (NULL != cc)
   {
     int cmp;
 
-    cmp = GNUNET_memcmp (cid,
-                  &cc->cid);
+    cmp = GNUNET_memcmp (cid, &cc->cid);
     if (0 == cmp)
     {
       /* Two peers picked the SAME random connection identifier at the
@@ -977,9 +914,7 @@ GCC_create (struct CadetPeer *destination,
 {
   struct GNUNET_CADET_ConnectionTunnelIdentifier cid;
 
-  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE,
-                              &cid,
-                              sizeof (cid));
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE, &cid, sizeof (cid));
   return connection_create (destination,
                             path,
                             off,
@@ -1002,8 +937,7 @@ GCC_create (struct CadetPeer *destination,
  *            yet have a #GNUNET_MQ_notify_sent() callback attached to it
  */
 void
-GCC_transmit (struct CadetConnection *cc,
-              struct GNUNET_MQ_Envelope *env)
+GCC_transmit (struct CadetConnection *cc, struct GNUNET_MQ_Envelope *env)
 {
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Scheduling message for transmission on %s\n",
@@ -1017,8 +951,7 @@ GCC_transmit (struct CadetConnection *cc,
     GNUNET_SCHEDULER_cancel (cc->task);
     cc->task = NULL;
   }
-  GCP_send (cc->mq_man,
-            env);
+  GCP_send (cc->mq_man, env);
 }
 
 
@@ -1030,8 +963,7 @@ GCC_transmit (struct CadetConnection *cc,
  * @return path to @a cc
  */
 struct CadetPeerPath *
-GCC_get_path (struct CadetConnection *cc,
-              unsigned int *off)
+GCC_get_path (struct CadetConnection *cc, unsigned int *off)
 {
   *off = cc->off;
   return cc->path;
@@ -1081,7 +1013,8 @@ GCC_2s (const struct CadetConnection *cc)
 }
 
 
-#define LOG2(level, ...) GNUNET_log_from_nocheck(level,"cadet-con",__VA_ARGS__)
+#define LOG2(level, ...) \
+  GNUNET_log_from_nocheck (level, "cadet-con", __VA_ARGS__)
 
 
 /**
@@ -1091,21 +1024,21 @@ GCC_2s (const struct CadetConnection *cc)
  * @param level Debug level to use.
  */
 void
-GCC_debug (struct CadetConnection *cc,
-           enum GNUNET_ErrorType level)
+GCC_debug (struct CadetConnection *cc, enum GNUNET_ErrorType level)
 {
-#if !defined(GNUNET_CULL_LOGGING)
+#if ! defined(GNUNET_CULL_LOGGING)
   int do_log;
 
   do_log = GNUNET_get_log_call_status (level & (~GNUNET_ERROR_TYPE_BULK),
                                        "cadet-con",
-                                       __FILE__, __FUNCTION__, __LINE__);
+                                       __FILE__,
+                                       __FUNCTION__,
+                                       __LINE__);
   if (0 == do_log)
     return;
   if (NULL == cc)
   {
-    LOG2 (level,
-          "Connection (NULL)\n");
+    LOG2 (level, "Connection (NULL)\n");
     return;
   }
   LOG2 (level,
diff --git a/src/cadet/gnunet-service-cadet_core.c b/src/cadet/gnunet-service-cadet_core.c
index 220a2b3cd..ec70a968b 100644
--- a/src/cadet/gnunet-service-cadet_core.c
+++ b/src/cadet/gnunet-service-cadet_core.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/>.
 
@@ -39,7 +39,7 @@
 #include "gnunet_statistics_service.h"
 #include "cadet_protocol.h"
 
-#define LOG(level, ...) GNUNET_log_from(level,"cadet-cor",__VA_ARGS__)
+#define LOG(level, ...) GNUNET_log_from (level, "cadet-cor", __VA_ARGS__)
 
 /**
  * Information we keep per direction for a route.
@@ -138,7 +138,6 @@ struct RouteDirection
    * Is @e mqm currently ready for transmission?
    */
   int is_ready;
-
 };
 
 
@@ -177,8 +176,6 @@ struct CadetRoute
    * Position of this route in the #route_heap.
    */
   struct GNUNET_CONTAINER_HeapNode *hn;
-
-  
 };
 
 
@@ -258,24 +255,17 @@ lower_rung (struct RouteDirection *dir)
   struct Rung *rung = dir->rung;
   struct Rung *prev;
 
-  GNUNET_CONTAINER_DLL_remove (rung->rd_head,
-                               rung->rd_tail,
-                               dir);
+  GNUNET_CONTAINER_DLL_remove (rung->rd_head, rung->rd_tail, dir);
   prev = rung->prev;
   GNUNET_assert (NULL != prev);
   if (prev->rung_off != rung->rung_off - 1)
   {
     prev = GNUNET_new (struct Rung);
     prev->rung_off = rung->rung_off - 1;
-    GNUNET_CONTAINER_DLL_insert_after (rung_head,
-                                       rung_tail,
-                                       rung->prev,
-                                       prev);
+    GNUNET_CONTAINER_DLL_insert_after (rung_head, rung_tail, rung->prev, prev);
   }
   GNUNET_assert (NULL != prev);
-  GNUNET_CONTAINER_DLL_insert (prev->rd_head,
-                               prev->rd_tail,
-                               dir);
+  GNUNET_CONTAINER_DLL_insert (prev->rd_head, prev->rd_tail, dir);
   dir->rung = prev;
 }
 
@@ -288,19 +278,13 @@ lower_rung (struct RouteDirection *dir)
  * @param env envelope to discard
  */
 static void
-discard_buffer (struct RouteDirection *dir,
-                struct GNUNET_MQ_Envelope *env)
+discard_buffer (struct RouteDirection *dir, struct GNUNET_MQ_Envelope *env)
 {
-  GNUNET_MQ_dll_remove (&dir->env_head,
-                        &dir->env_tail,
-                        env);
+  GNUNET_MQ_dll_remove (&dir->env_head, &dir->env_tail, env);
   cur_buffers--;
   GNUNET_MQ_discard (env);
   lower_rung (dir);
-  GNUNET_STATISTICS_set (stats,
-                         "# buffer use",
-                         cur_buffers,
-                         GNUNET_NO);
+  GNUNET_STATISTICS_set (stats, "# buffer use", cur_buffers, GNUNET_NO);
 }
 
 
@@ -322,12 +306,9 @@ discard_all_from_rung_tail ()
                               "# messages dropped due to full buffer",
                               1,
                               GNUNET_NO);
-    discard_buffer (dir,
-                    dir->env_head);
+    discard_buffer (dir, dir->env_head);
   }
-  GNUNET_CONTAINER_DLL_remove (rung_head,
-                               rung_tail,
-                               tail);
+  GNUNET_CONTAINER_DLL_remove (rung_head, rung_tail, tail);
   GNUNET_free (tail);
 }
 
@@ -345,7 +326,7 @@ static void
 route_message (struct CadetPeer *prev,
                const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid,
                const struct GNUNET_MessageHeader *msg,
-               const enum GNUNET_MQ_PriorityPreferences priority)
+               const enum GNUNET_MQ_PriorityPreferences priority)
 {
   struct CadetRoute *route;
   struct RouteDirection *dir;
@@ -371,17 +352,14 @@ route_message (struct CadetPeer *prev,
       /* No need to respond to these! */
       return;
     }
-    env = GNUNET_MQ_msg (bm,
-                         GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN);
+    env = GNUNET_MQ_msg (bm, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN);
     bm->cid = *cid;
     bm->peer1 = my_full_id;
-    GCP_send_ooo (prev,
-                  env);
+    GCP_send_ooo (prev, env);
     return;
   }
   route->last_use = GNUNET_TIME_absolute_get ();
-  GNUNET_CONTAINER_heap_update_cost (route->hn,
-                                     route->last_use.abs_value_us);
+  GNUNET_CONTAINER_heap_update_cost (route->hn, route->last_use.abs_value_us);
   dir = (prev == route->prev.hop) ? &route->next : &route->prev;
   if (GNUNET_YES == dir->is_ready)
   {
@@ -392,27 +370,24 @@ route_message (struct CadetPeer *prev,
          GNUNET_i2s (GCP_get_id (dir->hop)),
          GNUNET_sh2s (&cid->connection_of_tunnel));
     dir->is_ready = GNUNET_NO;
-    GCP_send (dir->mqm,
-              GNUNET_MQ_msg_copy (msg));
+    GCP_send (dir->mqm, GNUNET_MQ_msg_copy (msg));
     return;
   }
-  /* Check if buffering is disallowed, and if so, make sure we only queue
-     one message per direction. */
-  if ( (0 != (priority & GNUNET_MQ_PREF_NO_BUFFER)) &&
-       (NULL != dir->env_head) )
-    discard_buffer (dir,
-                    dir->env_head);
+  /* Check if low latency is required and if the previous message was
+     unreliable; if so, make sure we only queue one message per
+     direction (no buffering). */
+  if ((0 != (priority & GNUNET_MQ_PREF_LOW_LATENCY)) &&
+      (NULL != dir->env_head) &&
+      (0 ==
+       (GNUNET_MQ_env_get_options (dir->env_head) & GNUNET_MQ_PREF_UNRELIABLE)))
+    discard_buffer (dir, dir->env_head);
   /* Check for duplicates */
-  for (const struct GNUNET_MQ_Envelope *env = dir->env_head;
-       NULL != env;
+  for (const struct GNUNET_MQ_Envelope *env = dir->env_head; NULL != env;
        env = GNUNET_MQ_env_next (env))
   {
     const struct GNUNET_MessageHeader *hdr = GNUNET_MQ_env_get_msg (env);
 
-    if ( (hdr->size == msg->size) &&
-         (0 == memcmp (hdr,
-                       msg,
-                       ntohs (msg->size))) )
+    if ((hdr->size == msg->size) && (0 == memcmp (hdr, msg, ntohs (msg->size))))
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Received duplicate of message already in buffer, dropping\n");
@@ -443,31 +418,22 @@ route_message (struct CadetPeer *prev,
                                 "# messages dropped due to full buffer",
                                 1,
                                 GNUNET_NO);
-      discard_buffer (dir,
-                      dir->env_head);
+      discard_buffer (dir, dir->env_head);
       rung = dir->rung;
     }
   }
   /* remove 'dir' from current rung */
-  GNUNET_CONTAINER_DLL_remove (rung->rd_head,
-                               rung->rd_tail,
-                               dir);
+  GNUNET_CONTAINER_DLL_remove (rung->rd_head, rung->rd_tail, dir);
   /* make 'nxt' point to the next higher rung, create if necessary */
   nxt = rung->next;
-  if ( (NULL == nxt) ||
-       (rung->rung_off + 1 != nxt->rung_off) )
+  if ((NULL == nxt) || (rung->rung_off + 1 != nxt->rung_off))
   {
     nxt = GNUNET_new (struct Rung);
     nxt->rung_off = rung->rung_off + 1;
-    GNUNET_CONTAINER_DLL_insert_after (rung_head,
-                                       rung_tail,
-                                       rung,
-                                       nxt);
+    GNUNET_CONTAINER_DLL_insert_after (rung_head, rung_tail, rung, nxt);
   }
   /* insert 'dir' into next higher rung */
-  GNUNET_CONTAINER_DLL_insert (nxt->rd_head,
-                               nxt->rd_tail,
-                               dir);
+  GNUNET_CONTAINER_DLL_insert (nxt->rd_head, nxt->rd_tail, dir);
   dir->rung = nxt;
 
   /* add message into 'dir' buffer */
@@ -478,21 +444,21 @@ route_message (struct CadetPeer *prev,
        GNUNET_i2s (GCP_get_id (dir->hop)),
        GNUNET_sh2s (&cid->connection_of_tunnel));
   env = GNUNET_MQ_msg_copy (msg);
-  GNUNET_MQ_dll_insert_tail (&dir->env_head,
-                             &dir->env_tail,
-                             env);
+  GNUNET_MQ_env_set_options (env, priority);
+  if ((0 != (priority & GNUNET_MQ_PREF_LOW_LATENCY)) &&
+      (0 != (priority & GNUNET_MQ_PREF_OUT_OF_ORDER)) &&
+      (NULL != dir->env_head) &&
+      (0 == (GNUNET_MQ_env_get_options (dir->env_head) &
+             GNUNET_MQ_PREF_LOW_LATENCY)))
+    GNUNET_MQ_dll_insert_head (&dir->env_head, &dir->env_tail, env);
+  else
+    GNUNET_MQ_dll_insert_tail (&dir->env_head, &dir->env_tail, env);
   cur_buffers++;
-  GNUNET_STATISTICS_set (stats,
-                         "# buffer use",
-                         cur_buffers,
-                         GNUNET_NO);
+  GNUNET_STATISTICS_set (stats, "# buffer use", cur_buffers, GNUNET_NO);
   /* Clean up 'rung' if now empty (and not head) */
-  if ( (NULL == rung->rd_head) &&
-       (rung != rung_head) )
+  if ((NULL == rung->rd_head) && (rung != rung_head))
   {
-    GNUNET_CONTAINER_DLL_remove (rung_head,
-                                 rung_tail,
-                                 rung);
+    GNUNET_CONTAINER_DLL_remove (rung_head, rung_tail, rung);
     GNUNET_free (rung);
   }
 }
@@ -537,18 +503,14 @@ destroy_direction (struct RouteDirection *dir)
                               "# messages dropped due to route destruction",
                               1,
                               GNUNET_NO);
-    discard_buffer (dir,
-                    env);
+    discard_buffer (dir, env);
   }
   if (NULL != dir->mqm)
   {
-    GCP_request_mq_cancel (dir->mqm,
-                           NULL);
+    GCP_request_mq_cancel (dir->mqm, NULL);
     dir->mqm = NULL;
   }
-  GNUNET_CONTAINER_DLL_remove (rung_head->rd_head,
-                               rung_head->rd_tail,
-                               dir);
+  GNUNET_CONTAINER_DLL_remove (rung_head->rd_head, rung_head->rd_tail, dir);
 }
 
 
@@ -562,15 +524,15 @@ destroy_route (struct CadetRoute *route)
 {
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Destroying route from %s to %s of connection %s\n",
-       GNUNET_i2s  (GCP_get_id (route->prev.hop)),
+       GNUNET_i2s (GCP_get_id (route->prev.hop)),
        GNUNET_i2s2 (GCP_get_id (route->next.hop)),
        GNUNET_sh2s (&route->cid.connection_of_tunnel));
-  GNUNET_assert (route ==
-                 GNUNET_CONTAINER_heap_remove_node (route->hn));
-  GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multishortmap_remove (routes,
-                                                        &route->cid.connection_of_tunnel,
-                                                        route));
+  GNUNET_assert (route == GNUNET_CONTAINER_heap_remove_node (route->hn));
+  GNUNET_assert (
+    GNUNET_YES ==
+    GNUNET_CONTAINER_multishortmap_remove (routes,
+                                           &route->cid.connection_of_tunnel,
+                                           route));
   GNUNET_STATISTICS_set (stats,
                          "# routes",
                          GNUNET_CONTAINER_multishortmap_size (routes),
@@ -607,15 +569,13 @@ send_broken (struct RouteDirection *target,
        GNUNET_i2s2 (peer2),
        GNUNET_sh2s (&cid->connection_of_tunnel));
 
-  env = GNUNET_MQ_msg (bm,
-                       GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN);
+  env = GNUNET_MQ_msg (bm, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN);
   bm->cid = *cid;
   if (NULL != peer1)
     bm->peer1 = *peer1;
   if (NULL != peer2)
     bm->peer2 = *peer2;
-  GCP_request_mq_cancel (target->mqm,
-                         env);
+  GCP_request_mq_cancel (target->mqm, env);
   target->mqm = NULL;
 }
 
@@ -635,33 +595,22 @@ timeout_cb (void *cls)
   struct GNUNET_TIME_Absolute exp;
 
   timeout_task = NULL;
-  linger = GNUNET_TIME_relative_multiply (keepalive_period,
-                                          3);
+  linger = GNUNET_TIME_relative_multiply (keepalive_period, 3);
   while (NULL != (r = GNUNET_CONTAINER_heap_peek (route_heap)))
   {
-    exp = GNUNET_TIME_absolute_add (r->last_use,
-                                    linger);
+    exp = GNUNET_TIME_absolute_add (r->last_use, linger);
     if (0 != GNUNET_TIME_absolute_get_remaining (exp).rel_value_us)
     {
       /* Route not yet timed out, wait until it does. */
-      timeout_task = GNUNET_SCHEDULER_add_at (exp,
-                                              &timeout_cb,
-                                              NULL);
+      timeout_task = GNUNET_SCHEDULER_add_at (exp, &timeout_cb, NULL);
       return;
     }
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Sending BROKEN due to timeout (%s was last use, %s linger)\n",
-                GNUNET_STRINGS_absolute_time_to_string (r->last_use),
-                GNUNET_STRINGS_relative_time_to_string (linger,
-                                                        GNUNET_YES));
-    send_broken (&r->prev,
-                 &r->cid,
-                 NULL,
-                 NULL);
-    send_broken (&r->next,
-                 &r->cid,
-                 NULL,
-                 NULL);
+                "Sending BROKEN due to timeout (%s was last use, %s linger)\n",
+                GNUNET_STRINGS_absolute_time_to_string (r->last_use),
+                GNUNET_STRINGS_relative_time_to_string (linger, GNUNET_YES));
+    send_broken (&r->prev, &r->cid, NULL, NULL);
+    send_broken (&r->next, &r->cid, NULL, NULL);
     destroy_route (r);
   }
   /* No more routes left, so no need for a #timeout_task */
@@ -681,8 +630,7 @@ timeout_cb (void *cls)
  *                                 and the last envelope was discarded
  */
 static void
-dir_ready_cb (void *cls,
-              int ready)
+dir_ready_cb (void *cls, int ready)
 {
   struct RouteDirection *dir = cls;
   struct CadetRoute *route = dir->my_route;
@@ -695,28 +643,18 @@ dir_ready_cb (void *cls,
     dir->is_ready = GNUNET_YES;
     if (NULL != (env = dir->env_head))
     {
-      GNUNET_MQ_dll_remove (&dir->env_head,
-                            &dir->env_tail,
-                            env);
+      GNUNET_MQ_dll_remove (&dir->env_head, &dir->env_tail, env);
       cur_buffers--;
-      GNUNET_STATISTICS_set (stats,
-                             "# buffer use",
-                             cur_buffers,
-                             GNUNET_NO);
+      GNUNET_STATISTICS_set (stats, "# buffer use", cur_buffers, GNUNET_NO);
       lower_rung (dir);
       dir->is_ready = GNUNET_NO;
-      GCP_send (dir->mqm,
-                env);
+      GCP_send (dir->mqm, env);
     }
     return;
   }
   odir = (dir == &route->next) ? &route->prev : &route->next;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending BROKEN due to MQ going down\n");
-  send_broken (&route->next,
-               &route->cid,
-               GCP_get_id (odir->hop),
-               &my_full_id);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending BROKEN due to MQ going down\n");
+  send_broken (&route->next, &route->cid, GCP_get_id (odir->hop), &my_full_id);
   destroy_route (route);
 }
 
@@ -735,12 +673,8 @@ dir_init (struct RouteDirection *dir,
 {
   dir->hop = hop;
   dir->my_route = route;
-  dir->mqm = GCP_request_mq (hop,
-                             &dir_ready_cb,
-                             dir);
-  GNUNET_CONTAINER_DLL_insert (rung_head->rd_head,
-                               rung_head->rd_tail,
-                               dir);
+  dir->mqm = GCP_request_mq (hop, &dir_ready_cb, dir);
+  GNUNET_CONTAINER_DLL_insert (rung_head->rd_head, rung_head->rd_tail, dir);
   dir->rung = rung_head;
   GNUNET_assert (GNUNET_YES == dir->is_ready);
 }
@@ -757,21 +691,20 @@ dir_init (struct RouteDirection *dir,
  *        or NULL.
  */
 static void
-send_broken_without_mqm (struct CadetPeer *target,
-                         const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid,
-                         const struct GNUNET_PeerIdentity *failure_at)
+send_broken_without_mqm (
+  struct CadetPeer *target,
+  const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid,
+  const struct GNUNET_PeerIdentity *failure_at)
 {
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_CADET_ConnectionBrokenMessage *bm;
 
-  env = GNUNET_MQ_msg (bm,
-                       GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN);
+  env = GNUNET_MQ_msg (bm, GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN);
   bm->cid = *cid;
   bm->peer1 = my_full_id;
   if (NULL != failure_at)
     bm->peer2 = *failure_at;
-  GCP_send_ooo (target,
-                env);
+  GCP_send_ooo (target, env);
 }
 
 
@@ -782,12 +715,14 @@ send_broken_without_mqm (struct CadetPeer *target,
  * @param msg Message itself.
  */
 static void
-handle_connection_create (void *cls,
-                          const struct GNUNET_CADET_ConnectionCreateMessage *msg)
+handle_connection_create (
+  void *cls,
+  const struct GNUNET_CADET_ConnectionCreateMessage *msg)
 {
   struct CadetPeer *sender = cls;
   struct CadetPeer *next;
-  const struct GNUNET_PeerIdentity *pids = (const struct GNUNET_PeerIdentity *) &msg[1];
+  const struct GNUNET_PeerIdentity *pids =
+    (const struct GNUNET_PeerIdentity *) &msg[1];
   struct CadetRoute *route;
   uint16_t size = ntohs (msg->header.size) - sizeof (*msg);
   unsigned int path_length;
@@ -810,20 +745,19 @@ handle_connection_create (void *cls,
   {
     struct GNUNET_CONTAINER_MultiPeerMap *map;
 
-    map = GNUNET_CONTAINER_multipeermap_create (path_length * 2,
-                                                GNUNET_YES);
+    map = GNUNET_CONTAINER_multipeermap_create (path_length * 2, GNUNET_YES);
     GNUNET_assert (NULL != map);
-    for (unsigned int i=0;i<path_length;i++)
+    for (unsigned int i = 0; i < path_length; i++)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "CADET_CONNECTION_CREATE has peer %s at offset %u\n",
            GNUNET_i2s (&pids[i]),
            i);
-      if (GNUNET_SYSERR ==
-          GNUNET_CONTAINER_multipeermap_put (map,
-                                             &pids[i],
-                                             NULL,
-                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+      if (GNUNET_SYSERR == GNUNET_CONTAINER_multipeermap_put (
+                             map,
+                             &pids[i],
+                             NULL,
+                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
       {
         /* bogus request */
         GNUNET_CONTAINER_multipeermap_destroy (map);
@@ -836,9 +770,8 @@ handle_connection_create (void *cls,
     GNUNET_CONTAINER_multipeermap_destroy (map);
   }
   /* Initiator is at offset 0, find us */
-  for (off=1;off<path_length;off++)
-    if (0 == GNUNET_memcmp (&my_full_id,
-                     &pids[off]))
+  for (off = 1; off < path_length; off++)
+    if (0 == GNUNET_memcmp (&my_full_id, &pids[off]))
       break;
   if (off == path_length)
   {
@@ -848,16 +781,14 @@ handle_connection_create (void *cls,
     return;
   }
   /* Check previous hop */
-  if (sender != GCP_get (&pids[off - 1],
-                         GNUNET_NO))
+  if (sender != GCP_get (&pids[off - 1], GNUNET_NO))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Dropping CADET_CONNECTION_CREATE without sender at previous hop in the path\n");
     GNUNET_break_op (0);
     return;
   }
-  if (NULL !=
-      (route = get_route (&msg->cid)))
+  if (NULL != (route = get_route (&msg->cid)))
   {
     /* Duplicate CREATE, pass it on, previous one might have been lost! */
 
@@ -867,7 +798,8 @@ handle_connection_create (void *cls,
     route_message (sender,
                    &msg->cid,
                    &msg->header,
-                   GNUNET_MQ_PRIO_CRITICAL_CONTROL);
+                   GNUNET_MQ_PRIO_CRITICAL_CONTROL |
+                     GNUNET_MQ_PREF_LOW_LATENCY);
     return;
   }
   if (off == path_length - 1)
@@ -887,17 +819,14 @@ handle_connection_create (void *cls,
       return;
     }
 
-    origin = GCP_get (&pids[0],
-                      GNUNET_YES);
+    origin = GCP_get (&pids[0], GNUNET_YES);
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "I am destination for CADET_CONNECTION_CREATE message from %s for connection %s, building inverse path\n",
          GCP_2s (origin),
          GNUNET_sh2s (&msg->cid.connection_of_tunnel));
-    path = GCPP_get_path_from_route (path_length - 1,
-                                      pids);
+    path = GCPP_get_path_from_route (path_length - 1, pids);
     if (GNUNET_OK !=
-        GCT_add_inbound_connection (GCP_get_tunnel (origin,
-                                                    GNUNET_YES),
+        GCT_add_inbound_connection (GCP_get_tunnel (origin, GNUNET_YES),
                                     &msg->cid,
                                     path))
     {
@@ -908,18 +837,14 @@ handle_connection_create (void *cls,
            GCP_2s (sender),
            GNUNET_sh2s (&msg->cid.connection_of_tunnel),
            GCPP_2s (path));
-      send_broken_without_mqm (sender,
-                               &msg->cid,
-                               NULL);
+      send_broken_without_mqm (sender, &msg->cid, NULL);
       return;
     }
     return;
   }
   /* We are merely a hop on the way, check if we can support the route */
-  next = GCP_get (&pids[off + 1],
-                  GNUNET_NO);
-  if ( (NULL == next) ||
-       (GNUNET_NO == GCP_has_core_connection (next)) )
+  next = GCP_get (&pids[off + 1], GNUNET_NO);
+  if ((NULL == next) || (GNUNET_NO == GCP_has_core_connection (next)))
   {
     /* unworkable, send back BROKEN notification */
     LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -928,9 +853,7 @@ handle_connection_create (void *cls,
          GNUNET_sh2s (&msg->cid.connection_of_tunnel),
          GNUNET_i2s (&pids[off + 1]),
          off + 1);
-    send_broken_without_mqm (sender,
-                             &msg->cid,
-                             &pids[off + 1]);
+    send_broken_without_mqm (sender, &msg->cid, &pids[off + 1]);
     return;
   }
   if (max_routes <= GNUNET_CONTAINER_multishortmap_size (routes))
@@ -939,9 +862,7 @@ handle_connection_create (void *cls,
          "Received CADET_CONNECTION_CREATE from %s for %s. We have reached our route limit. Sending BROKEN\n",
          GCP_2s (sender),
          GNUNET_sh2s (&msg->cid.connection_of_tunnel));
-    send_broken_without_mqm (sender,
-                             &msg->cid,
-                             &pids[off - 1]);
+    send_broken_without_mqm (sender, &msg->cid, &pids[off - 1]);
     return;
   }
 
@@ -955,17 +876,14 @@ handle_connection_create (void *cls,
   route = GNUNET_new (struct CadetRoute);
   route->cid = msg->cid;
   route->last_use = GNUNET_TIME_absolute_get ();
-  dir_init (&route->prev,
-            route,
-            sender);
-  dir_init (&route->next,
-            route,
-            next);
+  dir_init (&route->prev, route, sender);
+  dir_init (&route->next, route, next);
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multishortmap_put (routes,
-                                                     &route->cid.connection_of_tunnel,
-                                                     route,
-                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+                 GNUNET_CONTAINER_multishortmap_put (
+                   routes,
+                   &route->cid.connection_of_tunnel,
+                   route,
+                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   GNUNET_STATISTICS_set (stats,
                          "# routes",
                          GNUNET_CONTAINER_multishortmap_size (routes),
@@ -974,15 +892,16 @@ handle_connection_create (void *cls,
                                             route,
                                             route->last_use.abs_value_us);
   if (NULL == timeout_task)
-    timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (keepalive_period,
-                                                                                3),
-                                                 &timeout_cb,
-                                                 NULL);
+    timeout_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (keepalive_period,
+                                                                   3),
+                                    &timeout_cb,
+                                    NULL);
   /* also pass CREATE message along to next hop */
   route_message (sender,
                  &msg->cid,
                  &msg->header,
-                 GNUNET_MQ_PRIO_CRITICAL_CONTROL);
+                 GNUNET_MQ_PRIO_CRITICAL_CONTROL | GNUNET_MQ_PREF_LOW_LATENCY);
 }
 
 
@@ -993,8 +912,9 @@ handle_connection_create (void *cls,
  * @param msg Message itself.
  */
 static void
-handle_connection_create_ack (void *cls,
-                              const struct GNUNET_CADET_ConnectionCreateAckMessage *msg)
+handle_connection_create_ack (
+  void *cls,
+  const struct GNUNET_CADET_ConnectionCreateAckMessage *msg)
 {
   struct CadetPeer *peer = cls;
   struct CadetConnection *cc;
@@ -1005,12 +925,9 @@ handle_connection_create_ack (void *cls,
   {
     /* verify ACK came from the right direction */
     unsigned int len;
-    struct CadetPeerPath *path = GCC_get_path (cc,
-                                               &len);
+    struct CadetPeerPath *path = GCC_get_path (cc, &len);
 
-    if (peer !=
-        GCPP_get_peer_at_offset (path,
-                                 0))
+    if (peer != GCPP_get_peer_at_offset (path, 0))
     {
       /* received ACK from unexpected direction, ignore! */
       GNUNET_break_op (0);
@@ -1027,7 +944,7 @@ handle_connection_create_ack (void *cls,
   route_message (peer,
                  &msg->cid,
                  &msg->header,
-                 GNUNET_MQ_PRIO_CRITICAL_CONTROL);
+                 GNUNET_MQ_PRIO_CRITICAL_CONTROL | GNUNET_MQ_PREF_LOW_LATENCY);
 }
 
 
@@ -1039,8 +956,9 @@ handle_connection_create_ack (void *cls,
  * @deprecated duplicate logic with #handle_destroy(); dedup!
  */
 static void
-handle_connection_broken (void *cls,
-                          const struct GNUNET_CADET_ConnectionBrokenMessage *msg)
+handle_connection_broken (
+  void *cls,
+  const struct GNUNET_CADET_ConnectionBrokenMessage *msg)
 {
   struct CadetPeer *peer = cls;
   struct CadetConnection *cc;
@@ -1052,12 +970,9 @@ handle_connection_broken (void *cls,
   {
     /* verify message came from the right direction */
     unsigned int len;
-    struct CadetPeerPath *path = GCC_get_path (cc,
-                                               &len);
+    struct CadetPeerPath *path = GCC_get_path (cc, &len);
 
-    if (peer !=
-        GCPP_get_peer_at_offset (path,
-                                 0))
+    if (peer != GCPP_get_peer_at_offset (path, 0))
     {
       /* received message from unexpected direction, ignore! */
       GNUNET_break_op (0);
@@ -1076,7 +991,7 @@ handle_connection_broken (void *cls,
   route_message (peer,
                  &msg->cid,
                  &msg->header,
-                 GNUNET_MQ_PREF_NO_BUFFER);
+                 GNUNET_MQ_PREF_LOW_LATENCY | GNUNET_MQ_PRIO_CRITICAL_CONTROL);
   route = get_route (&msg->cid);
   if (NULL != route)
     destroy_route (route);
@@ -1091,8 +1006,9 @@ handle_connection_broken (void *cls,
  * @param msg Message itself.
  */
 static void
-handle_connection_destroy (void *cls,
-                           const struct GNUNET_CADET_ConnectionDestroyMessage *msg)
+handle_connection_destroy (
+  void *cls,
+  const struct GNUNET_CADET_ConnectionDestroyMessage *msg)
 {
   struct CadetPeer *peer = cls;
   struct CadetConnection *cc;
@@ -1104,12 +1020,9 @@ handle_connection_destroy (void *cls,
   {
     /* verify message came from the right direction */
     unsigned int len;
-    struct CadetPeerPath *path = GCC_get_path (cc,
-                                               &len);
+    struct CadetPeerPath *path = GCC_get_path (cc, &len);
 
-    if (peer !=
-        GCPP_get_peer_at_offset (path,
-                                 0))
+    if (peer != GCPP_get_peer_at_offset (path, 0))
     {
       /* received message from unexpected direction, ignore! */
       GNUNET_break_op (0);
@@ -1130,7 +1043,7 @@ handle_connection_destroy (void *cls,
   route_message (peer,
                  &msg->cid,
                  &msg->header,
-                 GNUNET_MQ_PREF_NO_BUFFER);
+                 GNUNET_MQ_PREF_LOW_LATENCY | GNUNET_MQ_PRIO_CRITICAL_CONTROL);
   route = get_route (&msg->cid);
   if (NULL != route)
     destroy_route (route);
@@ -1162,19 +1075,15 @@ handle_tunnel_kx (void *cls,
   {
     /* verify message came from the right direction */
     unsigned int len;
-    struct CadetPeerPath *path = GCC_get_path (cc,
-                                               &len);
+    struct CadetPeerPath *path = GCC_get_path (cc, &len);
 
-    if (peer !=
-        GCPP_get_peer_at_offset (path,
-                                 0))
+    if (peer != GCPP_get_peer_at_offset (path, 0))
     {
       /* received message from unexpected direction, ignore! */
       GNUNET_break_op (0);
       return;
     }
-    GCC_handle_kx (cc,
-                   msg);
+    GCC_handle_kx (cc, msg);
     return;
   }
 
@@ -1182,7 +1091,7 @@ handle_tunnel_kx (void *cls,
   route_message (peer,
                  &msg->cid,
                  &msg->header,
-                 GNUNET_MQ_PRIO_CRITICAL_CONTROL);
+                 GNUNET_MQ_PRIO_CRITICAL_CONTROL | GNUNET_MQ_PREF_LOW_LATENCY);
 }
 
 
@@ -1193,8 +1102,9 @@ handle_tunnel_kx (void *cls,
  * @param msg Message itself.
  */
 static void
-handle_tunnel_kx_auth (void *cls,
-                       const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg)
+handle_tunnel_kx_auth (
+  void *cls,
+  const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg)
 {
   struct CadetPeer *peer = cls;
   struct CadetConnection *cc;
@@ -1205,19 +1115,15 @@ handle_tunnel_kx_auth (void *cls,
   {
     /* verify message came from the right direction */
     unsigned int len;
-    struct CadetPeerPath *path = GCC_get_path (cc,
-                                               &len);
+    struct CadetPeerPath *path = GCC_get_path (cc, &len);
 
-    if (peer !=
-        GCPP_get_peer_at_offset (path,
-                                 0))
+    if (peer != GCPP_get_peer_at_offset (path, 0))
     {
       /* received message from unexpected direction, ignore! */
       GNUNET_break_op (0);
       return;
     }
-    GCC_handle_kx_auth (cc,
-                        msg);
+    GCC_handle_kx_auth (cc, msg);
     return;
   }
 
@@ -1225,7 +1131,7 @@ handle_tunnel_kx_auth (void *cls,
   route_message (peer,
                  &msg->kx.cid,
                  &msg->kx.header,
-                 GNUNET_MQ_PRIO_CRITICAL_CONTROL);
+                 GNUNET_MQ_PRIO_CRITICAL_CONTROL | GNUNET_MQ_PREF_LOW_LATENCY);
 }
 
 
@@ -1264,26 +1170,19 @@ handle_tunnel_encrypted (void *cls,
   {
     /* verify message came from the right direction */
     unsigned int len;
-    struct CadetPeerPath *path = GCC_get_path (cc,
-                                               &len);
+    struct CadetPeerPath *path = GCC_get_path (cc, &len);
 
-    if (peer !=
-        GCPP_get_peer_at_offset (path,
-                                 0))
+    if (peer != GCPP_get_peer_at_offset (path, 0))
     {
       /* received message from unexpected direction, ignore! */
       GNUNET_break_op (0);
       return;
     }
-    GCC_handle_encrypted (cc,
-                          msg);
+    GCC_handle_encrypted (cc, msg);
     return;
   }
   /* We're just an intermediary peer, route the message along its path */
-  route_message (peer,
-                 &msg->cid,
-                 &msg->header,
-                 GNUNET_MQ_PRIO_CRITICAL_CONTROL);
+  route_message (peer, &msg->cid, &msg->header, GNUNET_MQ_PRIO_BEST_EFFORT);
 }
 
 
@@ -1300,17 +1199,14 @@ handle_tunnel_encrypted (void *cls,
  * @param my_identity ID of this peer, NULL if we failed
  */
 static void
-core_init_cb (void *cls,
-              const struct GNUNET_PeerIdentity *my_identity)
+core_init_cb (void *cls, const struct GNUNET_PeerIdentity *my_identity)
 {
   if (NULL == my_identity)
   {
     GNUNET_break (0);
     return;
   }
-  GNUNET_break (0 ==
-                GNUNET_memcmp (my_identity,
-                        &my_full_id));
+  GNUNET_break (0 == GNUNET_memcmp (my_identity, &my_full_id));
 }
 
 
@@ -1330,10 +1226,8 @@ core_connect_cb (void *cls,
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "CORE connection to peer %s was established.\n",
        GNUNET_i2s (peer));
-  cp = GCP_get (peer,
-                GNUNET_YES);
-  GCP_set_mq (cp,
-              mq);
+  cp = GCP_get (peer, GNUNET_YES);
+  GCP_set_mq (cp, mq);
   return cp;
 }
 
@@ -1354,8 +1248,7 @@ core_disconnect_cb (void *cls,
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "CORE connection to peer %s went down.\n",
        GNUNET_i2s (peer));
-  GCP_set_mq (cp,
-              NULL);
+  GCP_set_mq (cp, NULL);
 }
 
 
@@ -1367,52 +1260,48 @@ core_disconnect_cb (void *cls,
 void
 GCO_init (const struct GNUNET_CONFIGURATION_Handle *c)
 {
-  struct GNUNET_MQ_MessageHandler handlers[] = {
-    GNUNET_MQ_hd_var_size (connection_create,
-                           GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE,
-                           struct GNUNET_CADET_ConnectionCreateMessage,
-                           NULL),
-    GNUNET_MQ_hd_fixed_size (connection_create_ack,
-                             GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK,
-                             struct GNUNET_CADET_ConnectionCreateAckMessage,
-                             NULL),
-    GNUNET_MQ_hd_fixed_size (connection_broken,
-                             GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN,
-                             struct GNUNET_CADET_ConnectionBrokenMessage,
-                             NULL),
-    GNUNET_MQ_hd_fixed_size (connection_destroy,
-                             GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY,
-                             struct GNUNET_CADET_ConnectionDestroyMessage,
-                             NULL),
-    GNUNET_MQ_hd_fixed_size (tunnel_kx,
-                             GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX,
-                             struct GNUNET_CADET_TunnelKeyExchangeMessage,
-                             NULL),
-    GNUNET_MQ_hd_fixed_size (tunnel_kx_auth,
-                             GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH,
-                             struct GNUNET_CADET_TunnelKeyExchangeAuthMessage,
-                             NULL),
-    GNUNET_MQ_hd_var_size (tunnel_encrypted,
-                           GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED,
-                           struct GNUNET_CADET_TunnelEncryptedMessage,
-                           NULL),
-    GNUNET_MQ_handler_end ()
-  };
-
-  if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_number (c,
-                                             "CADET",
-                                             "MAX_ROUTES",
-                                             &max_routes))
-  max_routes = 5000;
-  if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_number (c,
-                                             "CADET",
-                                             "MAX_MSGS_QUEUE",
-                                             &max_buffers))
-  max_buffers = 10000;
-  routes = GNUNET_CONTAINER_multishortmap_create (1024,
-                                                  GNUNET_NO);
+  struct GNUNET_MQ_MessageHandler handlers[] =
+    {GNUNET_MQ_hd_var_size (connection_create,
+                            GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE,
+                            struct GNUNET_CADET_ConnectionCreateMessage,
+                            NULL),
+     GNUNET_MQ_hd_fixed_size (connection_create_ack,
+                              GNUNET_MESSAGE_TYPE_CADET_CONNECTION_CREATE_ACK,
+                              struct GNUNET_CADET_ConnectionCreateAckMessage,
+                              NULL),
+     GNUNET_MQ_hd_fixed_size (connection_broken,
+                              GNUNET_MESSAGE_TYPE_CADET_CONNECTION_BROKEN,
+                              struct GNUNET_CADET_ConnectionBrokenMessage,
+                              NULL),
+     GNUNET_MQ_hd_fixed_size (connection_destroy,
+                              GNUNET_MESSAGE_TYPE_CADET_CONNECTION_DESTROY,
+                              struct GNUNET_CADET_ConnectionDestroyMessage,
+                              NULL),
+     GNUNET_MQ_hd_fixed_size (tunnel_kx,
+                              GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX,
+                              struct GNUNET_CADET_TunnelKeyExchangeMessage,
+                              NULL),
+     GNUNET_MQ_hd_fixed_size (tunnel_kx_auth,
+                              GNUNET_MESSAGE_TYPE_CADET_TUNNEL_KX_AUTH,
+                              struct GNUNET_CADET_TunnelKeyExchangeAuthMessage,
+                              NULL),
+     GNUNET_MQ_hd_var_size (tunnel_encrypted,
+                            GNUNET_MESSAGE_TYPE_CADET_TUNNEL_ENCRYPTED,
+                            struct GNUNET_CADET_TunnelEncryptedMessage,
+                            NULL),
+     GNUNET_MQ_handler_end ()};
+
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (c,
+                                                          "CADET",
+                                                          "MAX_ROUTES",
+                                                          &max_routes))
+    max_routes = 5000;
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (c,
+                                                          "CADET",
+                                                          "MAX_MSGS_QUEUE",
+                                                          &max_buffers))
+    max_buffers = 10000;
+  routes = GNUNET_CONTAINER_multishortmap_create (1024, GNUNET_NO);
   route_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
   core = GNUNET_CORE_connect (c,
                               NULL,