1 files changed, 384 insertions, 382 deletions

diff --git a/src/cadet/gnunet-service-cadet_connection.c b/src/cadet/gnunet-service-cadet_connection.c
index e3c1a4124..66dc20481 100644
--- a/src/cadet/gnunet-service-cadet_connection.c
+++ b/src/cadet/gnunet-service-cadet_connection.c
@@ -35,7 +35,7 @@
 #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__)
 
 
 /**
@@ -43,13 +43,14 @@
  * 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)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 200)
 
 
 /**
  * All the states a connection can be in.
  */
-enum CadetConnectionState {
+enum CadetConnectionState
+{
   /**
    * Uninitialized status, we have not yet even gotten the message queue.
    */
@@ -81,7 +82,8 @@ enum CadetConnectionState {
 /**
  * Low-level connection to a destination.
  */
-struct CadetConnection {
+struct CadetConnection
+{
   /**
    * ID of the connection.
    */
@@ -181,10 +183,10 @@ struct CadetConnection {
  * @return NULL if connection was not found
  */
 struct CadetConnection *
-GCC_lookup(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
+GCC_lookup (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
 {
-  return GNUNET_CONTAINER_multishortmap_get(connections,
-                                            &cid->connection_of_tunnel);
+  return GNUNET_CONTAINER_multishortmap_get (connections,
+                                             &cid->connection_of_tunnel);
 }
 
 
@@ -197,9 +199,9 @@ GCC_lookup(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
  * @param new_mqm_ready new `mqm_ready` state for @a cc
  */
 static void
-update_state(struct CadetConnection *cc,
-             enum CadetConnectionState new_state,
-             int new_mqm_ready)
+update_state (struct CadetConnection *cc,
+              enum CadetConnectionState new_state,
+              int new_mqm_ready)
 {
   int old_ready;
   int new_ready;
@@ -213,7 +215,7 @@ update_state(struct CadetConnection *cc,
   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);
 }
 
 
@@ -224,34 +226,34 @@ update_state(struct CadetConnection *cc,
  * @param cc connection to destroy
  */
 static void
-GCC_destroy(struct CadetConnection *cc)
+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);
-      cc->mq_man = NULL;
-    }
+  {
+    GCP_request_mq_cancel (cc->mq_man, NULL);
+    cc->mq_man = NULL;
+  }
   if (NULL != cc->task)
-    {
-      GNUNET_SCHEDULER_cancel(cc->task);
-      cc->task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (cc->task);
+    cc->task = NULL;
+  }
   if (NULL != cc->keepalive_qe)
-    {
-      GCT_send_cancel(cc->keepalive_qe);
-      cc->keepalive_qe = NULL;
-    }
-  GCPP_del_connection(cc->path, cc->off, 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(
+    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);
+    GNUNET_CONTAINER_multishortmap_remove (connections,
+                                           &GCC_get_id (cc)
+                                           ->connection_of_tunnel,
+                                           cc));
+  GNUNET_free (cc);
 }
 
 
@@ -264,14 +266,14 @@ GCC_destroy(struct CadetConnection *cc)
  * @param cc connection to destroy
  */
 void
-GCC_destroy_without_core(struct CadetConnection *cc)
+GCC_destroy_without_core (struct CadetConnection *cc)
 {
   if (NULL != cc->ct)
-    {
-      GCT_connection_lost(cc->ct);
-      cc->ct = NULL;
-    }
-  GCC_destroy(cc);
+  {
+    GCT_connection_lost (cc->ct);
+    cc->ct = NULL;
+  }
+  GCC_destroy (cc);
 }
 
 
@@ -283,22 +285,22 @@ GCC_destroy_without_core(struct CadetConnection *cc)
  * @param cc connection to destroy
  */
 void
-GCC_destroy_without_tunnel(struct CadetConnection *cc)
+GCC_destroy_without_tunnel (struct CadetConnection *cc)
 {
   cc->ct = NULL;
   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);
-      destroy_msg->cid = cc->cid;
-      GCP_request_mq_cancel(cc->mq_man, env);
-      cc->mq_man = NULL;
-    }
-  GCC_destroy(cc);
+  {
+    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);
+    destroy_msg->cid = cc->cid;
+    GCP_request_mq_cancel (cc->mq_man, env);
+    cc->mq_man = NULL;
+  }
+  GCC_destroy (cc);
 }
 
 
@@ -309,7 +311,7 @@ GCC_destroy_without_tunnel(struct CadetConnection *cc)
  * @return corresponding entry in the tunnel's connection list
  */
 struct CadetTConnection *
-GCC_get_ct(struct CadetConnection *cc)
+GCC_get_ct (struct CadetConnection *cc)
 {
   return cc->ct;
 }
@@ -322,7 +324,7 @@ GCC_get_ct(struct CadetConnection *cc)
  * @return the metrics
  */
 const struct CadetConnectionMetrics *
-GCC_get_metrics(struct CadetConnection *cc)
+GCC_get_metrics (struct CadetConnection *cc)
 {
   return &cc->metrics;
 }
@@ -335,7 +337,7 @@ GCC_get_metrics(struct CadetConnection *cc)
  * @param cls the `struct CadetConnection` to keep alive.
  */
 static void
-send_keepalive(void *cls);
+send_keepalive (void *cls);
 
 
 /**
@@ -347,15 +349,15 @@ send_keepalive(void *cls);
  *            if transmission failed
  */
 static void
-keepalive_done(void *cls,
-               const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
+keepalive_done (void *cls,
+                const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
 {
   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);
+      GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc);
 }
 
 
@@ -366,31 +368,31 @@ keepalive_done(void *cls,
  * @param cls the `struct CadetConnection` to keep alive.
  */
 static void
-send_keepalive(void *cls)
+send_keepalive (void *cls)
 {
   struct CadetConnection *cc = cls;
   struct GNUNET_MessageHeader msg;
 
   cc->task = NULL;
-  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);
-      return;
-    }
-  GNUNET_assert(NULL != cc->ct);
-  GNUNET_assert(GNUNET_YES == cc->mqm_ready);
-  GNUNET_assert(NULL == cc->keepalive_qe);
-  LOG(GNUNET_ERROR_TYPE_INFO,
-      "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);
-  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);
+  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);
+    return;
+  }
+  GNUNET_assert (NULL != cc->ct);
+  GNUNET_assert (GNUNET_YES == cc->mqm_ready);
+  GNUNET_assert (NULL == cc->keepalive_qe);
+  LOG (GNUNET_ERROR_TYPE_INFO,
+       "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);
+  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);
 }
 
 
@@ -401,11 +403,11 @@ send_keepalive(void *cls)
  * @param cid connection identifier where we expect an ACK
  */
 void
-GCC_ack_expected(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
+GCC_ack_expected (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
 {
   struct CadetConnection *cc;
 
-  cc = GCC_lookup(cid);
+  cc = GCC_lookup (cid);
   if (NULL == cc)
     return; /* whopise, connection alredy down? */
   cc->metrics.num_acked_transmissions++;
@@ -421,11 +423,11 @@ GCC_ack_expected(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
  *            may have gotten back to us via a different connection).
  */
 void
-GCC_ack_observed(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
+GCC_ack_observed (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
 {
   struct CadetConnection *cc;
 
-  cc = GCC_lookup(cid);
+  cc = GCC_lookup (cid);
   if (NULL == cc)
     return; /* whopise, connection alredy down? */
   cc->metrics.num_successes++;
@@ -441,17 +443,17 @@ GCC_ack_observed(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid)
  * @param latency the observed latency
  */
 void
-GCC_latency_observed(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid,
-                     struct GNUNET_TIME_Relative latency)
+GCC_latency_observed (const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid,
+                      struct GNUNET_TIME_Relative latency)
 {
   struct CadetConnection *cc;
   double weight;
   double result;
 
-  cc = GCC_lookup(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;
@@ -460,10 +462,10 @@ 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;
+  cc->metrics.aged_latency.rel_value_us = (uint64_t) result;
 }
 
 
@@ -475,26 +477,26 @@ GCC_latency_observed(const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid,
  * @param cc the connection that got the ACK.
  */
 void
-GCC_handle_connection_create_ack(struct CadetConnection *cc)
+GCC_handle_connection_create_ack (struct CadetConnection *cc)
 {
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Received CADET_CONNECTION_CREATE_ACK for %s in state %d (%s)\n",
-      GCC_2s(cc),
-      cc->state,
-      (GNUNET_YES == cc->mqm_ready) ? "MQM ready" : "MQM busy");
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received CADET_CONNECTION_CREATE_ACK for %s in state %d (%s)\n",
+       GCC_2s (cc),
+       cc->state,
+       (GNUNET_YES == cc->mqm_ready) ? "MQM ready" : "MQM busy");
   if (CADET_CONNECTION_READY == cc->state)
     return; /* Duplicate ACK, ignore */
   if (NULL != cc->task)
-    {
-      GNUNET_SCHEDULER_cancel(cc->task);
-      cc->task = NULL;
-    }
-  cc->metrics.age = GNUNET_TIME_absolute_get();
-  update_state(cc, CADET_CONNECTION_READY, cc->mqm_ready);
+  {
+    GNUNET_SCHEDULER_cancel (cc->task);
+    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);
+      GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc);
 }
 
 
@@ -505,24 +507,24 @@ GCC_handle_connection_create_ack(struct CadetConnection *cc)
  * @param msg the key exchange message
  */
 void
-GCC_handle_kx(struct CadetConnection *cc,
-              const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg)
+GCC_handle_kx (struct CadetConnection *cc,
+               const struct GNUNET_CADET_TunnelKeyExchangeMessage *msg)
 {
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Received KX message with ephermal %s on CC %s in state %d\n",
-      GNUNET_e2s(&msg->ephemeral_key),
-      GNUNET_sh2s(&cc->cid.connection_of_tunnel),
-      cc->state);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received KX message with ephermal %s on CC %s in state %d\n",
+       GNUNET_e2s (&msg->ephemeral_key),
+       GNUNET_sh2s (&cc->cid.connection_of_tunnel),
+       cc->state);
   if (CADET_CONNECTION_SENT == cc->state)
-    {
-      /* We didn't get the CADET_CONNECTION_CREATE_ACK, but instead got payload. That's fine,
-         clearly something is working, so pretend we got an ACK. */
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Faking connection CADET_CONNECTION_CREATE_ACK for %s due to KX\n",
-          GCC_2s(cc));
-      GCC_handle_connection_create_ack(cc);
-    }
-  GCT_handle_kx(cc->ct, msg);
+  {
+    /* We didn't get the CADET_CONNECTION_CREATE_ACK, but instead got payload. That's fine,
+       clearly something is working, so pretend we got an ACK. */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Faking connection CADET_CONNECTION_CREATE_ACK for %s due to KX\n",
+         GCC_2s (cc));
+    GCC_handle_connection_create_ack (cc);
+  }
+  GCT_handle_kx (cc->ct, msg);
 }
 
 
@@ -533,24 +535,24 @@ GCC_handle_kx(struct CadetConnection *cc,
  * @param msg the key exchange message
  */
 void
-GCC_handle_kx_auth(struct CadetConnection *cc,
-                   const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg)
+GCC_handle_kx_auth (struct CadetConnection *cc,
+                    const struct GNUNET_CADET_TunnelKeyExchangeAuthMessage *msg)
 {
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Received KX AUTH message with ephermal %s on CC %s in state %d\n",
-      GNUNET_e2s(&msg->kx.ephemeral_key),
-      GNUNET_sh2s(&cc->cid.connection_of_tunnel),
-      cc->state);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received KX AUTH message with ephermal %s on CC %s in state %d\n",
+       GNUNET_e2s (&msg->kx.ephemeral_key),
+       GNUNET_sh2s (&cc->cid.connection_of_tunnel),
+       cc->state);
   if (CADET_CONNECTION_SENT == cc->state)
-    {
-      /* We didn't get the CADET_CONNECTION_CREATE_ACK, but instead got payload. That's fine,
-         clearly something is working, so pretend we got an ACK. */
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Faking connection CADET_CONNECTION_CREATE_ACK for %s due to KX\n",
-          GCC_2s(cc));
-      GCC_handle_connection_create_ack(cc);
-    }
-  GCT_handle_kx_auth(cc->ct, msg);
+  {
+    /* We didn't get the CADET_CONNECTION_CREATE_ACK, but instead got payload. That's fine,
+       clearly something is working, so pretend we got an ACK. */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Faking connection CADET_CONNECTION_CREATE_ACK for %s due to KX\n",
+         GCC_2s (cc));
+    GCC_handle_connection_create_ack (cc);
+  }
+  GCT_handle_kx_auth (cc->ct, msg);
 }
 
 
@@ -561,20 +563,20 @@ GCC_handle_kx_auth(struct CadetConnection *cc,
  * @param msg the encrypted message to decrypt
  */
 void
-GCC_handle_encrypted(struct CadetConnection *cc,
-                     const struct GNUNET_CADET_TunnelEncryptedMessage *msg)
+GCC_handle_encrypted (struct CadetConnection *cc,
+                      const struct GNUNET_CADET_TunnelEncryptedMessage *msg)
 {
   if (CADET_CONNECTION_SENT == cc->state)
-    {
-      /* We didn't get the CREATE_ACK, but instead got payload. That's fine,
-         clearly something is working, so pretend we got an ACK. */
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Faking connection ACK for %s due to ENCRYPTED payload\n",
-          GCC_2s(cc));
-      GCC_handle_connection_create_ack(cc);
-    }
-  cc->metrics.last_use = GNUNET_TIME_absolute_get();
-  GCT_handle_encrypted(cc->ct, msg);
+  {
+    /* We didn't get the CREATE_ACK, but instead got payload. That's fine,
+       clearly something is working, so pretend we got an ACK. */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Faking connection ACK for %s due to ENCRYPTED payload\n",
+         GCC_2s (cc));
+    GCC_handle_connection_create_ack (cc);
+  }
+  cc->metrics.last_use = GNUNET_TIME_absolute_get ();
+  GCT_handle_encrypted (cc->ct, msg);
 }
 
 
@@ -585,7 +587,7 @@ GCC_handle_encrypted(struct CadetConnection *cc,
  * @param cls the `struct CadetConnection` to initiate
  */
 static void
-send_create(void *cls)
+send_create (void *cls)
 {
   struct CadetConnection *cc = cls;
   struct GNUNET_CADET_ConnectionCreateMessage *create_msg;
@@ -593,27 +595,27 @@ send_create(void *cls)
   struct GNUNET_MQ_Envelope *env;
 
   cc->task = NULL;
-  GNUNET_assert(GNUNET_YES == cc->mqm_ready);
+  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 set the deprecated 'reliable' bit here that was removed.
+    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 = (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));
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Sending CADET_CONNECTION_CREATE message for %s with %u hops\n",
-      GCC_2s(cc),
-      cc->off + 2);
+    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),
+       cc->off + 2);
   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);
+  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);
 }
 
 
@@ -623,29 +625,29 @@ send_create(void *cls)
  * @param cls the `struct CadetConnection` to initiate
  */
 static void
-send_create_ack(void *cls)
+send_create_ack (void *cls)
 {
   struct CadetConnection *cc = cls;
   struct GNUNET_CADET_ConnectionCreateAckMessage *ack_msg;
   struct GNUNET_MQ_Envelope *env;
 
   cc->task = NULL;
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Sending CONNECTION_CREATE_ACK message for %s\n",
-      GCC_2s(cc));
-  GNUNET_assert(GNUNET_YES == cc->mqm_ready);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "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);
+    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);
+  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);
+      GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc);
+  GCP_send (cc->mq_man, env);
 }
 
 
@@ -657,31 +659,31 @@ send_create_ack(void *cls)
  * @param cc connection that got the duplicate CREATE
  */
 void
-GCC_handle_duplicate_create(struct CadetConnection *cc)
+GCC_handle_duplicate_create (struct CadetConnection *cc)
 {
   if (GNUNET_YES == cc->mqm_ready)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Got duplicate CREATE for %s, scheduling another ACK (%s)\n",
-          GCC_2s(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);
-      if (NULL != cc->task)
-        GNUNET_SCHEDULER_cancel(cc->task);
-      cc->task =
-        GNUNET_SCHEDULER_add_at(cc->create_ack_at, &send_create_ack, cc);
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Got duplicate CREATE for %s, scheduling another ACK (%s)\n",
+         GCC_2s (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);
+    if (NULL != cc->task)
+      GNUNET_SCHEDULER_cancel (cc->task);
+    cc->task =
+      GNUNET_SCHEDULER_add_at (cc->create_ack_at, &send_create_ack, cc);
+  }
   else
-    {
-      /* We are currently sending something else back, which
-         can only be an ACK or payload, either of which would
-         do. So actually no need to do anything. */
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Got duplicate CREATE for %s. MQ is busy, not queueing another ACK\n",
-          GCC_2s(cc));
-    }
+  {
+    /* We are currently sending something else back, which
+       can only be an ACK or payload, either of which would
+       do. So actually no need to do anything. */
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Got duplicate CREATE for %s. MQ is busy, not queueing another ACK\n",
+         GCC_2s (cc));
+  }
 }
 
 
@@ -696,67 +698,67 @@ 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);
+    cc->retry_delay = INITIAL_CONNECTION_CREATE_RETRY_DELAY;
+    if (NULL != cc->task)
     {
-      /* 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);
-      cc->retry_delay = INITIAL_CONNECTION_CREATE_RETRY_DELAY;
-      if (NULL != cc->task)
-        {
-          GNUNET_SCHEDULER_cancel(cc->task);
-          cc->task = NULL;
-        }
-      return;
+      GNUNET_SCHEDULER_cancel (cc->task);
+      cc->task = NULL;
     }
+    return;
+  }
 
-  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),
-      cc->state);
+  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),
+       cc->state);
   switch (cc->state)
+  {
+  case CADET_CONNECTION_NEW:
+    /* Transmit immediately */
+    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. */
+    GNUNET_assert (0);
+    break;
+
+  case CADET_CONNECTION_SENT:
+    /* Retry a bit later... */
+    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);
+    break;
+
+  case CADET_CONNECTION_READY:
+    if ((NULL == cc->keepalive_qe) && (GNUNET_YES == cc->mqm_ready) &&
+        (NULL == cc->task))
     {
-    case CADET_CONNECTION_NEW:
-      /* Transmit immediately */
-      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. */
-      GNUNET_assert(0);
-      break;
-
-    case CADET_CONNECTION_SENT:
-      /* Retry a bit later... */
-      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();
+      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_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))
-        {
-          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);
-        }
-      break;
+        GNUNET_SCHEDULER_add_delayed (keepalive_period, &send_keepalive, cc);
     }
+    break;
+  }
 }
 
 
@@ -775,44 +777,44 @@ manage_first_hop_mq(void *cls, int available)
  * @return handle to the connection
  */
 static struct CadetConnection *
-connection_create(struct CadetPeer *destination,
-                  struct CadetPeerPath *path,
-                  unsigned int off,
-                  struct CadetTConnection *ct,
-                  const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid,
-                  enum CadetConnectionState init_state,
-                  GCC_ReadyCallback ready_cb,
-                  void *ready_cb_cls)
+connection_create (struct CadetPeer *destination,
+                   struct CadetPeerPath *path,
+                   unsigned int off,
+                   struct CadetTConnection *ct,
+                   const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid,
+                   enum CadetConnectionState init_state,
+                   GCC_ReadyCallback ready_cb,
+                   void *ready_cb_cls)
 {
   struct CadetConnection *cc;
   struct CadetPeer *first_hop;
 
-  cc = GNUNET_new(struct CadetConnection);
+  cc = GNUNET_new (struct CadetConnection);
   cc->state = init_state;
   cc->ct = ct;
   cc->cid = *cid;
   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_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));
   cc->ready_cb = ready_cb;
   cc->ready_cb_cls = ready_cb_cls;
   cc->path = path;
   cc->off = off;
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Creating %s using path %s (offset: %u)\n",
-      GCC_2s(cc),
-      GCPP_2s(path),
-      off);
-  GCPP_add_connection(path, off, cc);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Creating %s using path %s (offset: %u)\n",
+       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);
+    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;
 }
 
@@ -831,64 +833,64 @@ connection_create(struct CadetPeer *destination,
  *         a connection that takes precedence on @a path
  */
 struct CadetConnection *
-GCC_create_inbound(struct CadetPeer *destination,
-                   struct CadetPeerPath *path,
-                   struct CadetTConnection *ct,
-                   const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid,
-                   GCC_ReadyCallback ready_cb,
-                   void *ready_cb_cls)
+GCC_create_inbound (struct CadetPeer *destination,
+                    struct CadetPeerPath *path,
+                    struct CadetTConnection *ct,
+                    const struct GNUNET_CADET_ConnectionTunnelIdentifier *cid,
+                    GCC_ReadyCallback ready_cb,
+                    void *ready_cb_cls)
 {
   struct CadetConnection *cc;
   unsigned int off;
 
-  off = GCPP_find_peer(path, destination);
-  GNUNET_assert(UINT_MAX != off);
-  cc = GCPP_get_connection(path, destination, off);
+  off = GCPP_find_peer (path, destination);
+  GNUNET_assert (UINT_MAX != off);
+  cc = GCPP_get_connection (path, destination, off);
   if (NULL != cc)
+  {
+    int cmp;
+
+    cmp = GNUNET_memcmp (cid, &cc->cid);
+    if (0 == cmp)
     {
-      int cmp;
-
-      cmp = GNUNET_memcmp(cid, &cc->cid);
-      if (0 == cmp)
-        {
-          /* Two peers picked the SAME random connection identifier at the
-             same time for the same path? Must be malicious.  Drop
-             connection (existing and inbound), even if it is the only
-             one. */
-          GNUNET_break_op(0);
-          GCT_connection_lost(cc->ct);
-          GCC_destroy_without_tunnel(cc);
-          return NULL;
-        }
-      if (0 < cmp)
-        {
-          /* drop existing */
-          LOG(GNUNET_ERROR_TYPE_DEBUG,
-              "Got two connections on %s, dropping my existing %s\n",
-              GCPP_2s(path),
-              GCC_2s(cc));
-          GCT_connection_lost(cc->ct);
-          GCC_destroy_without_tunnel(cc);
-        }
-      else
-        {
-          /* keep existing */
-          LOG(GNUNET_ERROR_TYPE_DEBUG,
-              "Got two connections on %s, keeping my existing %s\n",
-              GCPP_2s(path),
-              GCC_2s(cc));
-          return NULL;
-        }
+      /* Two peers picked the SAME random connection identifier at the
+         same time for the same path? Must be malicious.  Drop
+         connection (existing and inbound), even if it is the only
+         one. */
+      GNUNET_break_op (0);
+      GCT_connection_lost (cc->ct);
+      GCC_destroy_without_tunnel (cc);
+      return NULL;
     }
-
-  return connection_create(destination,
-                           path,
-                           off,
-                           ct,
-                           cid,
-                           CADET_CONNECTION_CREATE_RECEIVED,
-                           ready_cb,
-                           ready_cb_cls);
+    if (0 < cmp)
+    {
+      /* drop existing */
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Got two connections on %s, dropping my existing %s\n",
+           GCPP_2s (path),
+           GCC_2s (cc));
+      GCT_connection_lost (cc->ct);
+      GCC_destroy_without_tunnel (cc);
+    }
+    else
+    {
+      /* keep existing */
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Got two connections on %s, keeping my existing %s\n",
+           GCPP_2s (path),
+           GCC_2s (cc));
+      return NULL;
+    }
+  }
+
+  return connection_create (destination,
+                            path,
+                            off,
+                            ct,
+                            cid,
+                            CADET_CONNECTION_CREATE_RECEIVED,
+                            ready_cb,
+                            ready_cb_cls);
 }
 
 
@@ -905,24 +907,24 @@ GCC_create_inbound(struct CadetPeer *destination,
  * @return handle to the connection
  */
 struct CadetConnection *
-GCC_create(struct CadetPeer *destination,
-           struct CadetPeerPath *path,
-           unsigned int off,
-           struct CadetTConnection *ct,
-           GCC_ReadyCallback ready_cb,
-           void *ready_cb_cls)
+GCC_create (struct CadetPeer *destination,
+            struct CadetPeerPath *path,
+            unsigned int off,
+            struct CadetTConnection *ct,
+            GCC_ReadyCallback ready_cb,
+            void *ready_cb_cls)
 {
   struct GNUNET_CADET_ConnectionTunnelIdentifier cid;
 
-  GNUNET_CRYPTO_random_block(GNUNET_CRYPTO_QUALITY_NONCE, &cid, sizeof(cid));
-  return connection_create(destination,
-                           path,
-                           off,
-                           ct,
-                           &cid,
-                           CADET_CONNECTION_NEW,
-                           ready_cb,
-                           ready_cb_cls);
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE, &cid, sizeof(cid));
+  return connection_create (destination,
+                            path,
+                            off,
+                            ct,
+                            &cid,
+                            CADET_CONNECTION_NEW,
+                            ready_cb,
+                            ready_cb_cls);
 }
 
 
@@ -937,21 +939,21 @@ 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",
-      GCC_2s(cc));
-  GNUNET_assert(GNUNET_YES == cc->mqm_ready);
-  GNUNET_assert(CADET_CONNECTION_READY == cc->state);
-  cc->metrics.last_use = GNUNET_TIME_absolute_get();
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Scheduling message for transmission on %s\n",
+       GCC_2s (cc));
+  GNUNET_assert (GNUNET_YES == cc->mqm_ready);
+  GNUNET_assert (CADET_CONNECTION_READY == cc->state);
+  cc->metrics.last_use = GNUNET_TIME_absolute_get ();
   cc->mqm_ready = GNUNET_NO;
   if (NULL != cc->task)
-    {
-      GNUNET_SCHEDULER_cancel(cc->task);
-      cc->task = NULL;
-    }
-  GCP_send(cc->mq_man, env);
+  {
+    GNUNET_SCHEDULER_cancel (cc->task);
+    cc->task = NULL;
+  }
+  GCP_send (cc->mq_man, env);
 }
 
 
@@ -963,7 +965,7 @@ GCC_transmit(struct CadetConnection *cc, struct GNUNET_MQ_Envelope *env)
  * @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;
@@ -977,7 +979,7 @@ GCC_get_path(struct CadetConnection *cc, unsigned int *off)
  * @return unique number of the connection
  */
 const struct GNUNET_CADET_ConnectionTunnelIdentifier *
-GCC_get_id(struct CadetConnection *cc)
+GCC_get_id (struct CadetConnection *cc)
 {
   return &cc->cid;
 }
@@ -989,7 +991,7 @@ GCC_get_id(struct CadetConnection *cc)
  * @param cc Connection.
  */
 const char *
-GCC_2s(const struct CadetConnection *cc)
+GCC_2s (const struct CadetConnection *cc)
 {
   static char buf[128];
 
@@ -997,24 +999,24 @@ GCC_2s(const struct CadetConnection *cc)
     return "Connection(NULL)";
 
   if (NULL != cc->ct)
-    {
-      GNUNET_snprintf(buf,
-                      sizeof(buf),
-                      "Connection %s (%s)",
-                      GNUNET_sh2s(&cc->cid.connection_of_tunnel),
-                      GCT_2s(cc->ct->t));
-      return buf;
-    }
-  GNUNET_snprintf(buf,
-                  sizeof(buf),
-                  "Connection %s",
-                  GNUNET_sh2s(&cc->cid.connection_of_tunnel));
+  {
+    GNUNET_snprintf (buf,
+                     sizeof(buf),
+                     "Connection %s (%s)",
+                     GNUNET_sh2s (&cc->cid.connection_of_tunnel),
+                     GCT_2s (cc->ct->t));
+    return buf;
+  }
+  GNUNET_snprintf (buf,
+                   sizeof(buf),
+                   "Connection %s",
+                   GNUNET_sh2s (&cc->cid.connection_of_tunnel));
   return buf;
 }
 
 
 #define LOG2(level, ...) \
-  GNUNET_log_from_nocheck(level, "cadet-con", __VA_ARGS__)
+  GNUNET_log_from_nocheck (level, "cadet-con", __VA_ARGS__)
 
 
 /**
@@ -1024,30 +1026,30 @@ 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__);
+  do_log = GNUNET_get_log_call_status (level & (~GNUNET_ERROR_TYPE_BULK),
+                                       "cadet-con",
+                                       __FILE__,
+                                       __FUNCTION__,
+                                       __LINE__);
   if (0 == do_log)
     return;
   if (NULL == cc)
-    {
-      LOG2(level, "Connection (NULL)\n");
-      return;
-    }
-  LOG2(level,
-       "%s to %s via path %s in state %d is %s\n",
-       GCC_2s(cc),
-       GCP_2s(cc->destination),
-       GCPP_2s(cc->path),
-       cc->state,
-       (GNUNET_YES == cc->mqm_ready) ? "ready" : "busy");
+  {
+    LOG2 (level, "Connection (NULL)\n");
+    return;
+  }
+  LOG2 (level,
+        "%s to %s via path %s in state %d is %s\n",
+        GCC_2s (cc),
+        GCP_2s (cc->destination),
+        GCPP_2s (cc->path),
+        cc->state,
+        (GNUNET_YES == cc->mqm_ready) ? "ready" : "busy");
 #endif
 }