global reindent, now with uncrustify hook enabled

1 files changed, 378 insertions, 375 deletions

diff --git a/src/cadet/cadet_api.c b/src/cadet/cadet_api.c
index 61ff71b31..9aeedb616 100644
--- a/src/cadet/cadet_api.c
+++ b/src/cadet/cadet_api.c
@@ -30,12 +30,13 @@
 #include "cadet.h"
 #include "cadet_protocol.h"
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "cadet-api", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "cadet-api", __VA_ARGS__)
 
 /**
  * Opaque handle to the service.
  */
-struct GNUNET_CADET_Handle {
+struct GNUNET_CADET_Handle
+{
   /**
    * Message queue.
    */
@@ -76,7 +77,8 @@ struct GNUNET_CADET_Handle {
 /**
  * Opaque handle to a channel.
  */
-struct GNUNET_CADET_Channel {
+struct GNUNET_CADET_Channel
+{
   /**
    * Other end of the channel.
    */
@@ -140,7 +142,8 @@ struct GNUNET_CADET_Channel {
 /**
  * Opaque handle to a port.
  */
-struct GNUNET_CADET_Port {
+struct GNUNET_CADET_Port
+{
   /**
    * Port "number"
    */
@@ -191,10 +194,10 @@ struct GNUNET_CADET_Port {
  * @return The port handle if known, NULL otherwise.
  */
 static struct GNUNET_CADET_Port *
-find_port(const struct GNUNET_CADET_Handle *h,
-          const struct GNUNET_HashCode *hash)
+find_port (const struct GNUNET_CADET_Handle *h,
+           const struct GNUNET_HashCode *hash)
 {
-  return GNUNET_CONTAINER_multihashmap_get(h->ports, hash);
+  return GNUNET_CONTAINER_multihashmap_get (h->ports, hash);
 }
 
 
@@ -206,11 +209,11 @@ find_port(const struct GNUNET_CADET_Handle *h,
  * @return handle to the required channel or NULL if not found
  */
 static struct GNUNET_CADET_Channel *
-find_channel(struct GNUNET_CADET_Handle *h,
-             struct GNUNET_CADET_ClientChannelNumber ccn)
+find_channel (struct GNUNET_CADET_Handle *h,
+              struct GNUNET_CADET_ClientChannelNumber ccn)
 {
-  return GNUNET_CONTAINER_multihashmap32_get(h->channels,
-                                             ntohl(ccn.channel_of_client));
+  return GNUNET_CONTAINER_multihashmap32_get (h->channels,
+                                              ntohl (ccn.channel_of_client));
 }
 
 
@@ -222,33 +225,33 @@ find_channel(struct GNUNET_CADET_Handle *h,
  * @return Handle to the created channel.
  */
 static struct GNUNET_CADET_Channel *
-create_channel(struct GNUNET_CADET_Handle *h,
-               const struct GNUNET_CADET_ClientChannelNumber *ccnp)
+create_channel (struct GNUNET_CADET_Handle *h,
+                const struct GNUNET_CADET_ClientChannelNumber *ccnp)
 {
   struct GNUNET_CADET_Channel *ch;
   struct GNUNET_CADET_ClientChannelNumber ccn;
 
-  ch = GNUNET_new(struct GNUNET_CADET_Channel);
+  ch = GNUNET_new (struct GNUNET_CADET_Channel);
   ch->cadet = h;
   if (NULL == ccnp)
-    {
-      while (NULL != find_channel(h, h->next_ccn))
-        h->next_ccn.channel_of_client =
-          htonl(GNUNET_CADET_LOCAL_CHANNEL_ID_CLI |
-                (1 + ntohl(h->next_ccn.channel_of_client)));
-      ccn = h->next_ccn;
-    }
+  {
+    while (NULL != find_channel (h, h->next_ccn))
+      h->next_ccn.channel_of_client =
+        htonl (GNUNET_CADET_LOCAL_CHANNEL_ID_CLI
+               | (1 + ntohl (h->next_ccn.channel_of_client)));
+    ccn = h->next_ccn;
+  }
   else
-    {
-      ccn = *ccnp;
-    }
+  {
+    ccn = *ccnp;
+  }
   ch->ccn = ccn;
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONTAINER_multihashmap32_put(
-                  h->channels,
-                  ntohl(ch->ccn.channel_of_client),
-                  ch,
-                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multihashmap32_put (
+                   h->channels,
+                   ntohl (ch->ccn.channel_of_client),
+                   ch,
+                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   return ch;
 }
 
@@ -264,31 +267,31 @@ create_channel(struct GNUNET_CADET_Handle *h,
  * @param call_cleaner Whether to call the cleaner handler.
  */
 static void
-destroy_channel(struct GNUNET_CADET_Channel *ch)
+destroy_channel (struct GNUNET_CADET_Channel *ch)
 {
   struct GNUNET_CADET_Handle *h = ch->cadet;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Destroying channel %X of %p\n",
-      htonl(ch->ccn.channel_of_client),
-      h);
-  GNUNET_assert(
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Destroying channel %X of %p\n",
+       htonl (ch->ccn.channel_of_client),
+       h);
+  GNUNET_assert (
     GNUNET_YES ==
-    GNUNET_CONTAINER_multihashmap32_remove(h->channels,
-                                           ntohl(ch->ccn.channel_of_client),
-                                           ch));
+    GNUNET_CONTAINER_multihashmap32_remove (h->channels,
+                                            ntohl (ch->ccn.channel_of_client),
+                                            ch));
   if (NULL != ch->mq_cont)
-    {
-      GNUNET_SCHEDULER_cancel(ch->mq_cont);
-      ch->mq_cont = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (ch->mq_cont);
+    ch->mq_cont = NULL;
+  }
   /* signal channel destruction */
   if (NULL != ch->disconnects)
-    ch->disconnects(ch->ctx, ch);
+    ch->disconnects (ch->ctx, ch);
   if (NULL != ch->pending_env)
-    GNUNET_MQ_discard(ch->pending_env);
-  GNUNET_MQ_destroy(ch->mq);
-  GNUNET_free(ch);
+    GNUNET_MQ_discard (ch->pending_env);
+  GNUNET_MQ_destroy (ch->mq);
+  GNUNET_free (ch);
 }
 
 
@@ -299,7 +302,7 @@ destroy_channel(struct GNUNET_CADET_Channel *ch)
  * @param h handle to the cadet
  */
 static void
-reconnect(struct GNUNET_CADET_Handle *h);
+reconnect (struct GNUNET_CADET_Handle *h);
 
 
 /**
@@ -312,17 +315,17 @@ reconnect(struct GNUNET_CADET_Handle *h);
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-open_port_cb(void *cls, const struct GNUNET_HashCode *id, void *value)
+open_port_cb (void *cls, const struct GNUNET_HashCode *id, void *value)
 {
   struct GNUNET_CADET_Handle *h = cls;
   struct GNUNET_CADET_Port *port = value;
   struct GNUNET_CADET_PortMessage *msg;
   struct GNUNET_MQ_Envelope *env;
 
-  (void)id;
-  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN);
+  (void) id;
+  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN);
   msg->port = port->id;
-  GNUNET_MQ_send(h->mq, env);
+  GNUNET_MQ_send (h->mq, env);
   return GNUNET_OK;
 }
 
@@ -334,14 +337,14 @@ open_port_cb(void *cls, const struct GNUNET_HashCode *id, void *value)
  * @param cls closure (cadet handle)
  */
 static void
-reconnect_cbk(void *cls)
+reconnect_cbk (void *cls)
 {
   struct GNUNET_CADET_Handle *h = cls;
 
   h->reconnect_task = NULL;
-  h->reconnect_time = GNUNET_TIME_STD_BACKOFF(h->reconnect_time);
-  reconnect(h);
-  GNUNET_CONTAINER_multihashmap_iterate(h->ports, &open_port_cb, h);
+  h->reconnect_time = GNUNET_TIME_STD_BACKOFF (h->reconnect_time);
+  reconnect (h);
+  GNUNET_CONTAINER_multihashmap_iterate (h->ports, &open_port_cb, h);
 }
 
 
@@ -351,12 +354,12 @@ reconnect_cbk(void *cls)
  * @param ch Channel to notify about.
  */
 static void
-notify_window_size(struct GNUNET_CADET_Channel *ch)
+notify_window_size (struct GNUNET_CADET_Channel *ch)
 {
   if (NULL != ch->window_changes)
-    ch->window_changes(ch->ctx,
-                       ch,  /* FIXME: remove 'ch'? */
-                       ch->allow_send);
+    ch->window_changes (ch->ctx,
+                        ch, /* FIXME: remove 'ch'? */
+                        ch->allow_send);
 }
 
 
@@ -366,32 +369,32 @@ notify_window_size(struct GNUNET_CADET_Channel *ch)
  * @param cls Closure (channel whose mq to activate).
  */
 static void
-cadet_mq_send_now(void *cls)
+cadet_mq_send_now (void *cls)
 {
   struct GNUNET_CADET_Channel *ch = cls;
   struct GNUNET_MQ_Envelope *env = ch->pending_env;
 
   ch->mq_cont = NULL;
   if (0 == ch->allow_send)
-    {
-      /* how did we get here? */
-      GNUNET_break(0);
-      return;
-    }
+  {
+    /* how did we get here? */
+    GNUNET_break (0);
+    return;
+  }
   if (NULL == env)
-    {
-      /* how did we get here? */
-      GNUNET_break(0);
-      return;
-    }
+  {
+    /* how did we get here? */
+    GNUNET_break (0);
+    return;
+  }
   ch->allow_send--;
   ch->pending_env = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Sending message on channel %s to CADET, new window size is %u\n",
-             GNUNET_i2s(&ch->peer),
-             ch->allow_send);
-  GNUNET_MQ_send(ch->cadet->mq, env);
-  GNUNET_MQ_impl_send_continue(ch->mq);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending message on channel %s to CADET, new window size is %u\n",
+              GNUNET_i2s (&ch->peer),
+              ch->allow_send);
+  GNUNET_MQ_send (ch->cadet->mq, env);
+  GNUNET_MQ_impl_send_continue (ch->mq);
 }
 
 
@@ -408,9 +411,9 @@ cadet_mq_send_now(void *cls)
  * @param impl_state state of the implementation
  */
 static void
-cadet_mq_send_impl(struct GNUNET_MQ_Handle *mq,
-                   const struct GNUNET_MessageHeader *msg,
-                   void *impl_state)
+cadet_mq_send_impl (struct GNUNET_MQ_Handle *mq,
+                    const struct GNUNET_MessageHeader *msg,
+                    void *impl_state)
 {
   struct GNUNET_CADET_Channel *ch = impl_state;
   struct GNUNET_CADET_Handle *h = ch->cadet;
@@ -421,31 +424,31 @@ cadet_mq_send_impl(struct GNUNET_MQ_Handle *mq,
   enum GNUNET_MQ_PriorityPreferences pp;
 
   if (NULL == h->mq)
-    {
-      /* We're currently reconnecting, pretend this worked */
-      GNUNET_MQ_impl_send_continue(mq);
-      return;
-    }
-  orig_env = GNUNET_MQ_get_current_envelope(mq);
-  pp = GNUNET_MQ_env_get_options(orig_env);
+  {
+    /* We're currently reconnecting, pretend this worked */
+    GNUNET_MQ_impl_send_continue (mq);
+    return;
+  }
+  orig_env = GNUNET_MQ_get_current_envelope (mq);
+  pp = GNUNET_MQ_env_get_options (orig_env);
 
   /* check message size for sanity */
-  msize = ntohs(msg->size);
+  msize = ntohs (msg->size);
   if (msize > GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE)
-    {
-      GNUNET_break(0);
-      GNUNET_MQ_impl_send_continue(mq);
-      return;
-    }
-  env = GNUNET_MQ_msg_nested_mh(cadet_msg,
-                                GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA,
-                                msg);
+  {
+    GNUNET_break (0);
+    GNUNET_MQ_impl_send_continue (mq);
+    return;
+  }
+  env = GNUNET_MQ_msg_nested_mh (cadet_msg,
+                                 GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA,
+                                 msg);
   cadet_msg->ccn = ch->ccn;
-  cadet_msg->pp = htonl((uint32_t)pp);
-  GNUNET_assert(NULL == ch->pending_env);
+  cadet_msg->pp = htonl ((uint32_t) pp);
+  GNUNET_assert (NULL == ch->pending_env);
   ch->pending_env = env;
   if (0 < ch->allow_send)
-    ch->mq_cont = GNUNET_SCHEDULER_add_now(&cadet_mq_send_now, ch);
+    ch->mq_cont = GNUNET_SCHEDULER_add_now (&cadet_mq_send_now, ch);
 }
 
 
@@ -457,11 +460,11 @@ cadet_mq_send_impl(struct GNUNET_MQ_Handle *mq,
  * @param impl_state state of the implementation
  */
 static void
-cadet_mq_destroy_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
+cadet_mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
 {
   struct GNUNET_CADET_Channel *ch = impl_state;
 
-  GNUNET_assert(mq == ch->mq);
+  GNUNET_assert (mq == ch->mq);
   ch->mq = NULL;
 }
 
@@ -475,25 +478,25 @@ cadet_mq_destroy_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
  * @param error error code
  */
 static void
-cadet_mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
+cadet_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
 {
   struct GNUNET_CADET_Channel *ch = cls;
 
   if (GNUNET_MQ_ERROR_NO_MATCH == error)
-    {
-      /* Got a message we did not understand, still try to continue! */
-      GNUNET_break_op(0);
-      GNUNET_CADET_receive_done(ch);
-    }
+  {
+    /* Got a message we did not understand, still try to continue! */
+    GNUNET_break_op (0);
+    GNUNET_CADET_receive_done (ch);
+  }
   else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "MQ error in communication with CADET: %d\n",
-                 error);
-      if (NULL != ch->disconnects)
-        ch->disconnects(ch->ctx, ch);
-      GNUNET_CADET_channel_destroy(ch);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "MQ error in communication with CADET: %d\n",
+                error);
+    if (NULL != ch->disconnects)
+      ch->disconnects (ch->ctx, ch);
+    GNUNET_CADET_channel_destroy (ch);
+  }
 }
 
 
@@ -505,19 +508,19 @@ cadet_mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
  * @param impl_state state specific to the implementation
  */
 static void
-cadet_mq_cancel_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
+cadet_mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
 {
   struct GNUNET_CADET_Channel *ch = impl_state;
 
-  (void)mq;
-  GNUNET_assert(NULL != ch->pending_env);
-  GNUNET_MQ_discard(ch->pending_env);
+  (void) mq;
+  GNUNET_assert (NULL != ch->pending_env);
+  GNUNET_MQ_discard (ch->pending_env);
   ch->pending_env = NULL;
   if (NULL != ch->mq_cont)
-    {
-      GNUNET_SCHEDULER_cancel(ch->mq_cont);
-      ch->mq_cont = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (ch->mq_cont);
+    ch->mq_cont = NULL;
+  }
 }
 
 
@@ -528,7 +531,7 @@ cadet_mq_cancel_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
  * @param msg   A message with the details of the new incoming channel
  */
 static void
-handle_channel_created(
+handle_channel_created (
   void *cls,
   const struct GNUNET_CADET_LocalChannelCreateMessage *msg)
 {
@@ -540,52 +543,52 @@ handle_channel_created(
 
   ccn = msg->ccn;
   port_number = &msg->port;
-  if (ntohl(ccn.channel_of_client) >= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
-    {
-      GNUNET_break(0);
-      return;
-    }
-  port = find_port(h, port_number);
+  if (ntohl (ccn.channel_of_client) >= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  port = find_port (h, port_number);
   if (NULL == port)
-    {
-      /* We could have closed the port but the service didn't know about it yet
-       * This is not an error.
-       */
-      struct GNUNET_CADET_LocalChannelDestroyMessage *d_msg;
-      struct GNUNET_MQ_Envelope *env;
-
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "No handler for incoming channel %X (on port %s, recently closed?)\n",
-          ntohl(ccn.channel_of_client),
-          GNUNET_h2s(port_number));
-      env =
-        GNUNET_MQ_msg(d_msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY);
-      d_msg->ccn = msg->ccn;
-      GNUNET_MQ_send(h->mq, env);
-      return;
-    }
-
-  ch = create_channel(h, &ccn);
+  {
+    /* We could have closed the port but the service didn't know about it yet
+     * This is not an error.
+     */
+    struct GNUNET_CADET_LocalChannelDestroyMessage *d_msg;
+    struct GNUNET_MQ_Envelope *env;
+
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "No handler for incoming channel %X (on port %s, recently closed?)\n",
+         ntohl (ccn.channel_of_client),
+         GNUNET_h2s (port_number));
+    env =
+      GNUNET_MQ_msg (d_msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY);
+    d_msg->ccn = msg->ccn;
+    GNUNET_MQ_send (h->mq, env);
+    return;
+  }
+
+  ch = create_channel (h, &ccn);
   ch->peer = msg->peer;
   ch->incoming_port = port;
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Creating incoming channel %X [%s] %p\n",
-      ntohl(ccn.channel_of_client),
-      GNUNET_h2s(port_number),
-      ch);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Creating incoming channel %X [%s] %p\n",
+       ntohl (ccn.channel_of_client),
+       GNUNET_h2s (port_number),
+       ch);
 
-  GNUNET_assert(NULL != port->connects);
+  GNUNET_assert (NULL != port->connects);
   ch->window_changes = port->window_changes;
   ch->disconnects = port->disconnects;
-  ch->mq = GNUNET_MQ_queue_for_callbacks(&cadet_mq_send_impl,
-                                         &cadet_mq_destroy_impl,
-                                         &cadet_mq_cancel_impl,
-                                         ch,
-                                         port->handlers,
-                                         &cadet_mq_error_handler,
-                                         ch);
-  ch->ctx = port->connects(port->cls, ch, &msg->peer);
-  GNUNET_MQ_set_handlers_closure(ch->mq, ch->ctx);
+  ch->mq = GNUNET_MQ_queue_for_callbacks (&cadet_mq_send_impl,
+                                          &cadet_mq_destroy_impl,
+                                          &cadet_mq_cancel_impl,
+                                          ch,
+                                          port->handlers,
+                                          &cadet_mq_error_handler,
+                                          ch);
+  ch->ctx = port->connects (port->cls, ch, &msg->peer);
+  GNUNET_MQ_set_handlers_closure (ch->mq, ch->ctx);
 }
 
 
@@ -596,25 +599,25 @@ handle_channel_created(
  * @param msg   A message with the details of the channel being destroyed
  */
 static void
-handle_channel_destroy(
+handle_channel_destroy (
   void *cls,
   const struct GNUNET_CADET_LocalChannelDestroyMessage *msg)
 {
   struct GNUNET_CADET_Handle *h = cls;
   struct GNUNET_CADET_Channel *ch;
 
-  ch = find_channel(h, msg->ccn);
+  ch = find_channel (h, msg->ccn);
   if (NULL == ch)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Received channel destroy for unknown channel %X from CADET service (recently close?)\n",
-          ntohl(msg->ccn.channel_of_client));
-      return;
-    }
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Received channel destroy for channel %X from CADET service\n",
-      ntohl(msg->ccn.channel_of_client));
-  destroy_channel(ch);
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Received channel destroy for unknown channel %X from CADET service (recently close?)\n",
+         ntohl (msg->ccn.channel_of_client));
+    return;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received channel destroy for channel %X from CADET service\n",
+       ntohl (msg->ccn.channel_of_client));
+  destroy_channel (ch);
 }
 
 
@@ -627,17 +630,17 @@ handle_channel_destroy(
  *         #GNUNET_SYSERR otherwise
  */
 static int
-check_local_data(void *cls, const struct GNUNET_CADET_LocalData *message)
+check_local_data (void *cls, const struct GNUNET_CADET_LocalData *message)
 {
   uint16_t size;
 
-  (void)cls;
-  size = ntohs(message->header.size);
+  (void) cls;
+  size = ntohs (message->header.size);
   if (sizeof(*message) + sizeof(struct GNUNET_MessageHeader) > size)
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -649,7 +652,7 @@ check_local_data(void *cls, const struct GNUNET_CADET_LocalData *message)
  * @param message A message encapsulating the data
  */
 static void
-handle_local_data(void *cls, const struct GNUNET_CADET_LocalData *message)
+handle_local_data (void *cls, const struct GNUNET_CADET_LocalData *message)
 {
   struct GNUNET_CADET_Handle *h = cls;
   const struct GNUNET_MessageHeader *payload;
@@ -657,25 +660,25 @@ handle_local_data(void *cls, const struct GNUNET_CADET_LocalData *message)
   uint16_t type;
   int fwd;
 
-  ch = find_channel(h, message->ccn);
+  ch = find_channel (h, message->ccn);
   if (NULL == ch)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Unknown channel %X for incoming data (recently closed?)\n",
-          ntohl(message->ccn.channel_of_client));
-      return;
-    }
-
-  payload = (const struct GNUNET_MessageHeader *)&message[1];
-  type = ntohs(payload->type);
-  fwd = ntohl(ch->ccn.channel_of_client) <= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI;
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Got a %s data on channel %s [%X] of type %u\n",
-      fwd ? "FWD" : "BWD",
-      GNUNET_i2s(&ch->peer),
-      ntohl(message->ccn.channel_of_client),
-      type);
-  GNUNET_MQ_inject_message(ch->mq, payload);
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Unknown channel %X for incoming data (recently closed?)\n",
+         ntohl (message->ccn.channel_of_client));
+    return;
+  }
+
+  payload = (const struct GNUNET_MessageHeader *) &message[1];
+  type = ntohs (payload->type);
+  fwd = ntohl (ch->ccn.channel_of_client) <= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Got a %s data on channel %s [%X] of type %u\n",
+       fwd ? "FWD" : "BWD",
+       GNUNET_i2s (&ch->peer),
+       ntohl (message->ccn.channel_of_client),
+       type);
+  GNUNET_MQ_inject_message (ch->mq, payload);
 }
 
 
@@ -687,37 +690,37 @@ handle_local_data(void *cls, const struct GNUNET_CADET_LocalData *message)
  * @param message Message itself.
  */
 static void
-handle_local_ack(void *cls, const struct GNUNET_CADET_LocalAck *message)
+handle_local_ack (void *cls, const struct GNUNET_CADET_LocalAck *message)
 {
   struct GNUNET_CADET_Handle *h = cls;
   struct GNUNET_CADET_Channel *ch;
 
-  ch = find_channel(h, message->ccn);
+  ch = find_channel (h, message->ccn);
   if (NULL == ch)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "ACK on unknown channel %X\n",
-          ntohl(message->ccn.channel_of_client));
-      return;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "ACK on unknown channel %X\n",
+         ntohl (message->ccn.channel_of_client));
+    return;
+  }
   ch->allow_send++;
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Got an ACK on mq channel %X (peer %s); new window size is %u!\n",
-      ntohl(ch->ccn.channel_of_client),
-      GNUNET_i2s(&ch->peer),
-      ch->allow_send);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Got an ACK on mq channel %X (peer %s); new window size is %u!\n",
+       ntohl (ch->ccn.channel_of_client),
+       GNUNET_i2s (&ch->peer),
+       ch->allow_send);
   if (NULL == ch->pending_env)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Got an ACK on mq channel %X, allow send now %u!\n",
-          ntohl(ch->ccn.channel_of_client),
-          ch->allow_send);
-      notify_window_size(ch);
-      return;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Got an ACK on mq channel %X, allow send now %u!\n",
+         ntohl (ch->ccn.channel_of_client),
+         ch->allow_send);
+    notify_window_size (ch);
+    return;
+  }
   if (NULL != ch->mq_cont)
     return; /* already working on it! */
-  ch->mq_cont = GNUNET_SCHEDULER_add_now(&cadet_mq_send_now, ch);
+  ch->mq_cont = GNUNET_SCHEDULER_add_now (&cadet_mq_send_now, ch);
 }
 
 
@@ -731,16 +734,16 @@ handle_local_ack(void *cls, const struct GNUNET_CADET_LocalAck *message)
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-destroy_channel_cb(void *cls, uint32_t cid, void *value)
+destroy_channel_cb (void *cls, uint32_t cid, void *value)
 {
   /* struct GNUNET_CADET_Handle *handle = cls; */
   struct GNUNET_CADET_Channel *ch = value;
 
-  (void)cls;
-  (void)cid;
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Destroying channel due to GNUNET_CADET_disconnect()\n");
-  destroy_channel(ch);
+  (void) cls;
+  (void) cid;
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Destroying channel due to GNUNET_CADET_disconnect()\n");
+  destroy_channel (ch);
   return GNUNET_OK;
 }
 
@@ -754,17 +757,17 @@ destroy_channel_cb(void *cls, uint32_t cid, void *value)
  * @param error error code
  */
 static void
-handle_mq_error(void *cls, enum GNUNET_MQ_Error error)
+handle_mq_error (void *cls, enum GNUNET_MQ_Error error)
 {
   struct GNUNET_CADET_Handle *h = cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "MQ ERROR: %u\n", error);
-  GNUNET_CONTAINER_multihashmap32_iterate(h->channels, &destroy_channel_cb, h);
-  GNUNET_MQ_destroy(h->mq);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MQ ERROR: %u\n", error);
+  GNUNET_CONTAINER_multihashmap32_iterate (h->channels, &destroy_channel_cb, h);
+  GNUNET_MQ_destroy (h->mq);
   h->mq = NULL;
-  GNUNET_assert(NULL == h->reconnect_task);
+  GNUNET_assert (NULL == h->reconnect_task);
   h->reconnect_task =
-    GNUNET_SCHEDULER_add_delayed(h->reconnect_time, &reconnect_cbk, h);
+    GNUNET_SCHEDULER_add_delayed (h->reconnect_time, &reconnect_cbk, h);
 }
 
 
@@ -775,30 +778,30 @@ handle_mq_error(void *cls, enum GNUNET_MQ_Error error)
  * @param h handle to the cadet
  */
 static void
-reconnect(struct GNUNET_CADET_Handle *h)
+reconnect (struct GNUNET_CADET_Handle *h)
 {
   struct GNUNET_MQ_MessageHandler handlers[] =
-  { GNUNET_MQ_hd_fixed_size(channel_created,
-                            GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE,
-                            struct GNUNET_CADET_LocalChannelCreateMessage,
-                            h),
-    GNUNET_MQ_hd_fixed_size(channel_destroy,
-                            GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY,
-                            struct GNUNET_CADET_LocalChannelDestroyMessage,
-                            h),
-    GNUNET_MQ_hd_var_size(local_data,
-                          GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA,
-                          struct GNUNET_CADET_LocalData,
-                          h),
-    GNUNET_MQ_hd_fixed_size(local_ack,
-                            GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK,
-                            struct GNUNET_CADET_LocalAck,
-                            h),
-    GNUNET_MQ_handler_end() };
-
-  GNUNET_assert(NULL == h->mq);
+  { GNUNET_MQ_hd_fixed_size (channel_created,
+                             GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE,
+                             struct GNUNET_CADET_LocalChannelCreateMessage,
+                             h),
+    GNUNET_MQ_hd_fixed_size (channel_destroy,
+                             GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY,
+                             struct GNUNET_CADET_LocalChannelDestroyMessage,
+                             h),
+    GNUNET_MQ_hd_var_size (local_data,
+                           GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA,
+                           struct GNUNET_CADET_LocalData,
+                           h),
+    GNUNET_MQ_hd_fixed_size (local_ack,
+                             GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK,
+                             struct GNUNET_CADET_LocalAck,
+                             h),
+    GNUNET_MQ_handler_end () };
+
+  GNUNET_assert (NULL == h->mq);
   h->mq =
-    GNUNET_CLIENT_connect(h->cfg, "cadet", handlers, &handle_mq_error, h);
+    GNUNET_CLIENT_connect (h->cfg, "cadet", handlers, &handle_mq_error, h);
 }
 
 
@@ -812,16 +815,16 @@ reconnect(struct GNUNET_CADET_Handle *h)
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-destroy_port_cb(void *cls, const struct GNUNET_HashCode *id, void *value)
+destroy_port_cb (void *cls, const struct GNUNET_HashCode *id, void *value)
 {
   /* struct GNUNET_CADET_Handle *handle = cls; */
   struct GNUNET_CADET_Port *port = value;
 
-  (void)cls;
-  (void)id;
+  (void) cls;
+  (void) id;
   /* This is a warning, the app should have cleanly closed all open ports */
-  GNUNET_break(0);
-  GNUNET_CADET_close_port(port);
+  GNUNET_break (0);
+  GNUNET_CADET_close_port (port);
   return GNUNET_OK;
 }
 
@@ -835,29 +838,29 @@ destroy_port_cb(void *cls, const struct GNUNET_HashCode *id, void *value)
  * @param handle connection to cadet to disconnect
  */
 void
-GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
+GNUNET_CADET_disconnect (struct GNUNET_CADET_Handle *handle)
 {
-  GNUNET_CONTAINER_multihashmap_iterate(handle->ports,
-                                        &destroy_port_cb,
-                                        handle);
-  GNUNET_CONTAINER_multihashmap_destroy(handle->ports);
+  GNUNET_CONTAINER_multihashmap_iterate (handle->ports,
+                                         &destroy_port_cb,
+                                         handle);
+  GNUNET_CONTAINER_multihashmap_destroy (handle->ports);
   handle->ports = NULL;
-  GNUNET_CONTAINER_multihashmap32_iterate(handle->channels,
-                                          &destroy_channel_cb,
-                                          handle);
-  GNUNET_CONTAINER_multihashmap32_destroy(handle->channels);
+  GNUNET_CONTAINER_multihashmap32_iterate (handle->channels,
+                                           &destroy_channel_cb,
+                                           handle);
+  GNUNET_CONTAINER_multihashmap32_destroy (handle->channels);
   handle->channels = NULL;
   if (NULL != handle->mq)
-    {
-      GNUNET_MQ_destroy(handle->mq);
-      handle->mq = NULL;
-    }
+  {
+    GNUNET_MQ_destroy (handle->mq);
+    handle->mq = NULL;
+  }
   if (NULL != handle->reconnect_task)
-    {
-      GNUNET_SCHEDULER_cancel(handle->reconnect_task);
-      handle->reconnect_task = NULL;
-    }
-  GNUNET_free(handle);
+  {
+    GNUNET_SCHEDULER_cancel (handle->reconnect_task);
+    handle->reconnect_task = NULL;
+  }
+  GNUNET_free (handle);
 }
 
 
@@ -868,22 +871,22 @@ GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
  * @param p Port handle.
  */
 void
-GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
+GNUNET_CADET_close_port (struct GNUNET_CADET_Port *p)
 {
-  GNUNET_assert(
+  GNUNET_assert (
     GNUNET_YES ==
-    GNUNET_CONTAINER_multihashmap_remove(p->cadet->ports, &p->id, p));
+    GNUNET_CONTAINER_multihashmap_remove (p->cadet->ports, &p->id, p));
   if (NULL != p->cadet->mq)
-    {
-      struct GNUNET_CADET_PortMessage *msg;
-      struct GNUNET_MQ_Envelope *env;
-
-      env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE);
-      msg->port = p->id;
-      GNUNET_MQ_send(p->cadet->mq, env);
-    }
-  GNUNET_free_non_null(p->handlers);
-  GNUNET_free(p);
+  {
+    struct GNUNET_CADET_PortMessage *msg;
+    struct GNUNET_MQ_Envelope *env;
+
+    env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE);
+    msg->port = p->id;
+    GNUNET_MQ_send (p->cadet->mq, env);
+  }
+  GNUNET_free_non_null (p->handlers);
+  GNUNET_free (p);
 }
 
 
@@ -897,22 +900,22 @@ GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
  * @param channel Channel handle, becomes invalid after this call.
  */
 void
-GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
+GNUNET_CADET_channel_destroy (struct GNUNET_CADET_Channel *channel)
 {
   struct GNUNET_CADET_Handle *h = channel->cadet;
   struct GNUNET_CADET_LocalChannelDestroyMessage *msg;
   struct GNUNET_MQ_Envelope *env;
 
   if (NULL != h->mq)
-    {
-      env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY);
-      msg->ccn = channel->ccn;
-      GNUNET_MQ_send(h->mq, env);
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "Destroying channel due to GNUNET_CADET_channel_destroy()\n");
+  {
+    env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY);
+    msg->ccn = channel->ccn;
+    GNUNET_MQ_send (h->mq, env);
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Destroying channel due to GNUNET_CADET_channel_destroy()\n");
   channel->disconnects = NULL;
-  destroy_channel(channel);
+  destroy_channel (channel);
 }
 
 
@@ -926,19 +929,19 @@ GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
  * @return Union with an answer to the query.
  */
 const union GNUNET_CADET_ChannelInfo *
-GNUNET_CADET_channel_get_info(struct GNUNET_CADET_Channel *channel,
-                              enum GNUNET_CADET_ChannelInfoOption option,
-                              ...)
+GNUNET_CADET_channel_get_info (struct GNUNET_CADET_Channel *channel,
+                               enum GNUNET_CADET_ChannelInfoOption option,
+                               ...)
 {
   switch (option)
-    {
-    case GNUNET_CADET_OPTION_PEER:
-      return (const union GNUNET_CADET_ChannelInfo *)&channel->peer;
-
-    default:
-      GNUNET_break(0);
-      return NULL;
-    }
+  {
+  case GNUNET_CADET_OPTION_PEER:
+    return (const union GNUNET_CADET_ChannelInfo *) &channel->peer;
+
+  default:
+    GNUNET_break (0);
+    return NULL;
+  }
 }
 
 
@@ -948,17 +951,17 @@ GNUNET_CADET_channel_get_info(struct GNUNET_CADET_Channel *channel,
  * @param ch Channel on which to send the ACK.
  */
 void
-GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
+GNUNET_CADET_receive_done (struct GNUNET_CADET_Channel *channel)
 {
   struct GNUNET_CADET_LocalAck *msg;
   struct GNUNET_MQ_Envelope *env;
 
-  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK);
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Sending ACK on channel %X\n",
-      ntohl(channel->ccn.channel_of_client));
+  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Sending ACK on channel %X\n",
+       ntohl (channel->ccn.channel_of_client));
   msg->ccn = channel->ccn;
-  GNUNET_MQ_send(channel->cadet->mq, env);
+  GNUNET_MQ_send (channel->cadet->mq, env);
 }
 
 
@@ -970,23 +973,23 @@ GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
  * @return Handle to the cadet service NULL on error.
  */
 struct GNUNET_CADET_Handle *
-GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
+GNUNET_CADET_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_CADET_Handle *h;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "GNUNET_CADET_connect()\n");
-  h = GNUNET_new(struct GNUNET_CADET_Handle);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "GNUNET_CADET_connect()\n");
+  h = GNUNET_new (struct GNUNET_CADET_Handle);
   h->cfg = cfg;
-  h->ports = GNUNET_CONTAINER_multihashmap_create(4, GNUNET_YES);
-  h->channels = GNUNET_CONTAINER_multihashmap32_create(4);
-  reconnect(h);
+  h->ports = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_YES);
+  h->channels = GNUNET_CONTAINER_multihashmap32_create (4);
+  reconnect (h);
   if (NULL == h->mq)
-    {
-      GNUNET_break(0);
-      GNUNET_CADET_disconnect(h);
-      return NULL;
-    }
-  h->next_ccn.channel_of_client = htonl(GNUNET_CADET_LOCAL_CHANNEL_ID_CLI);
+  {
+    GNUNET_break (0);
+    GNUNET_CADET_disconnect (h);
+    return NULL;
+  }
+  h->next_ccn.channel_of_client = htonl (GNUNET_CADET_LOCAL_CHANNEL_ID_CLI);
   return h;
 }
 
@@ -1004,41 +1007,41 @@ GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @return Port handle, NULL if port is in use
  */
 struct GNUNET_CADET_Port *
-GNUNET_CADET_open_port(struct GNUNET_CADET_Handle *h,
-                       const struct GNUNET_HashCode *port,
-                       GNUNET_CADET_ConnectEventHandler connects,
-                       void *connects_cls,
-                       GNUNET_CADET_WindowSizeEventHandler window_changes,
-                       GNUNET_CADET_DisconnectEventHandler disconnects,
-                       const struct GNUNET_MQ_MessageHandler *handlers)
+GNUNET_CADET_open_port (struct GNUNET_CADET_Handle *h,
+                        const struct GNUNET_HashCode *port,
+                        GNUNET_CADET_ConnectEventHandler connects,
+                        void *connects_cls,
+                        GNUNET_CADET_WindowSizeEventHandler window_changes,
+                        GNUNET_CADET_DisconnectEventHandler disconnects,
+                        const struct GNUNET_MQ_MessageHandler *handlers)
 {
   struct GNUNET_CADET_Port *p;
 
-  GNUNET_assert(NULL != connects);
-  GNUNET_assert(NULL != disconnects);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Listening to CADET port %s\n",
-             GNUNET_h2s(port));
+  GNUNET_assert (NULL != connects);
+  GNUNET_assert (NULL != disconnects);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Listening to CADET port %s\n",
+              GNUNET_h2s (port));
 
-  p = GNUNET_new(struct GNUNET_CADET_Port);
+  p = GNUNET_new (struct GNUNET_CADET_Port);
   p->cadet = h;
   p->id = *port;
-  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put(
+  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (
         h->ports,
         &p->id,
         p,
         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
-    {
-      GNUNET_free(p);
-      return NULL;
-    }
+  {
+    GNUNET_free (p);
+    return NULL;
+  }
   p->connects = connects;
   p->cls = connects_cls;
   p->window_changes = window_changes;
   p->disconnects = disconnects;
-  p->handlers = GNUNET_MQ_copy_handlers(handlers);
+  p->handlers = GNUNET_MQ_copy_handlers (handlers);
 
-  GNUNET_assert(GNUNET_OK == open_port_cb(h, &p->id, p));
+  GNUNET_assert (GNUNET_OK == open_port_cb (h, &p->id, p));
   return p;
 }
 
@@ -1062,45 +1065,45 @@ GNUNET_CADET_open_port(struct GNUNET_CADET_Handle *h,
  * @return Handle to the channel.
  */
 struct GNUNET_CADET_Channel *
-GNUNET_CADET_channel_create(struct GNUNET_CADET_Handle *h,
-                            void *channel_cls,
-                            const struct GNUNET_PeerIdentity *destination,
-                            const struct GNUNET_HashCode *port,
-                            GNUNET_CADET_WindowSizeEventHandler window_changes,
-                            GNUNET_CADET_DisconnectEventHandler disconnects,
-                            const struct GNUNET_MQ_MessageHandler *handlers)
+GNUNET_CADET_channel_create (struct GNUNET_CADET_Handle *h,
+                             void *channel_cls,
+                             const struct GNUNET_PeerIdentity *destination,
+                             const struct GNUNET_HashCode *port,
+                             GNUNET_CADET_WindowSizeEventHandler window_changes,
+                             GNUNET_CADET_DisconnectEventHandler disconnects,
+                             const struct GNUNET_MQ_MessageHandler *handlers)
 {
   struct GNUNET_CADET_Channel *ch;
   struct GNUNET_CADET_LocalChannelCreateMessage *msg;
   struct GNUNET_MQ_Envelope *env;
 
-  GNUNET_assert(NULL != disconnects);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Creating channel to peer %s at port %s\n",
-             GNUNET_i2s(destination),
-             GNUNET_h2s(port));
-  ch = create_channel(h, NULL);
+  GNUNET_assert (NULL != disconnects);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Creating channel to peer %s at port %s\n",
+              GNUNET_i2s (destination),
+              GNUNET_h2s (port));
+  ch = create_channel (h, NULL);
   ch->ctx = channel_cls;
   ch->peer = *destination;
   ch->window_changes = window_changes;
   ch->disconnects = disconnects;
 
   /* Create MQ for channel */
-  ch->mq = GNUNET_MQ_queue_for_callbacks(&cadet_mq_send_impl,
-                                         &cadet_mq_destroy_impl,
-                                         &cadet_mq_cancel_impl,
-                                         ch,
-                                         handlers,
-                                         &cadet_mq_error_handler,
-                                         ch);
-  GNUNET_MQ_set_handlers_closure(ch->mq, channel_cls);
+  ch->mq = GNUNET_MQ_queue_for_callbacks (&cadet_mq_send_impl,
+                                          &cadet_mq_destroy_impl,
+                                          &cadet_mq_cancel_impl,
+                                          ch,
+                                          handlers,
+                                          &cadet_mq_error_handler,
+                                          ch);
+  GNUNET_MQ_set_handlers_closure (ch->mq, channel_cls);
 
   /* Request channel creation to service */
-  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE);
+  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE);
   msg->ccn = ch->ccn;
   msg->port = *port;
   msg->peer = *destination;
-  GNUNET_MQ_send(h->mq, env);
+  GNUNET_MQ_send (h->mq, env);
   return ch;
 }
 
@@ -1113,7 +1116,7 @@ GNUNET_CADET_channel_create(struct GNUNET_CADET_Handle *h,
  * @return NULL if @a channel is not yet connected.
  */
 struct GNUNET_MQ_Handle *
-GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel)
+GNUNET_CADET_get_mq (const struct GNUNET_CADET_Channel *channel)
 {
   return channel->mq;
 }