uncrustify as demanded.

1 files changed, 300 insertions, 303 deletions

diff --git a/src/transport/transport_api_core.c b/src/transport/transport_api_core.c
index 224af5de2..d88461d5a 100644
--- a/src/transport/transport_api_core.c
+++ b/src/transport/transport_api_core.c
@@ -16,7 +16,7 @@
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 
 /**
  * @file transport/transport_api_core.c
@@ -32,7 +32,7 @@
 #include "gnunet_transport_service.h"
 #include "transport.h"
 
-#define LOG(kind, ...) GNUNET_log_from (kind, "transport-api-core", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from(kind, "transport-api-core", __VA_ARGS__)
 
 /**
  * If we could not send any payload to a peer for this amount of
@@ -49,8 +49,7 @@
 /**
  * Entry in hash table of all of our current (connected) neighbours.
  */
-struct Neighbour
-{
+struct Neighbour {
   /**
    * Overall transport handle.
    */
@@ -119,9 +118,7 @@ struct Neighbour
  * Handle for the transport service (includes all of the
  * state for the transport service).
  */
-struct GNUNET_TRANSPORT_CoreHandle
-{
-
+struct GNUNET_TRANSPORT_CoreHandle {
   /**
    * Closure for the callbacks.
    */
@@ -203,7 +200,7 @@ struct GNUNET_TRANSPORT_CoreHandle
  * @param h transport service to reconnect
  */
 static void
-disconnect_and_schedule_reconnect (struct GNUNET_TRANSPORT_CoreHandle *h);
+disconnect_and_schedule_reconnect(struct GNUNET_TRANSPORT_CoreHandle *h);
 
 
 /**
@@ -214,10 +211,10 @@ disconnect_and_schedule_reconnect (struct GNUNET_TRANSPORT_CoreHandle *h);
  * @return NULL if no such peer entry exists
  */
 static struct Neighbour *
-neighbour_find (struct GNUNET_TRANSPORT_CoreHandle *h,
-                const struct GNUNET_PeerIdentity *peer)
+neighbour_find(struct GNUNET_TRANSPORT_CoreHandle *h,
+               const struct GNUNET_PeerIdentity *peer)
 {
-  return GNUNET_CONTAINER_multipeermap_get (h->neighbours, peer);
+  return GNUNET_CONTAINER_multipeermap_get(h->neighbours, peer);
 }
 
 
@@ -228,17 +225,17 @@ neighbour_find (struct GNUNET_TRANSPORT_CoreHandle *h,
  * @param cls the `struct Neighbour` that has excess bandwidth
  */
 static void
-notify_excess_cb (void *cls)
+notify_excess_cb(void *cls)
 {
   struct Neighbour *n = cls;
   struct GNUNET_TRANSPORT_CoreHandle *h = n->h;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Notifying CORE that more bandwidth is available for %s\n",
-       GNUNET_i2s (&n->id));
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Notifying CORE that more bandwidth is available for %s\n",
+      GNUNET_i2s(&n->id));
 
   if (NULL != h->neb_cb)
-    h->neb_cb (h->cls, &n->id, n->handlers_cls);
+    h->neb_cb(h->cls, &n->id, n->handlers_cls);
 }
 
 
@@ -253,33 +250,33 @@ notify_excess_cb (void *cls)
  *         #GNUNET_NO if not.
  */
 static int
-neighbour_delete (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
+neighbour_delete(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 {
   struct GNUNET_TRANSPORT_CoreHandle *handle = cls;
   struct Neighbour *n = value;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Dropping entry for neighbour `%s'.\n",
-       GNUNET_i2s (key));
-  GNUNET_BANDWIDTH_tracker_notification_stop (&n->out_tracker);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Dropping entry for neighbour `%s'.\n",
+      GNUNET_i2s(key));
+  GNUNET_BANDWIDTH_tracker_notification_stop(&n->out_tracker);
   if (NULL != handle->nd_cb)
-    handle->nd_cb (handle->cls, &n->id, n->handlers_cls);
+    handle->nd_cb(handle->cls, &n->id, n->handlers_cls);
   if (NULL != n->timeout_task)
-  {
-    GNUNET_SCHEDULER_cancel (n->timeout_task);
-    n->timeout_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(n->timeout_task);
+      n->timeout_task = NULL;
+    }
   if (NULL != n->env)
-  {
-    GNUNET_MQ_send_cancel (n->env);
-    n->env = NULL;
-  }
-  GNUNET_MQ_destroy (n->mq);
-  GNUNET_assert (NULL == n->mq);
-  GNUNET_assert (
+    {
+      GNUNET_MQ_send_cancel(n->env);
+      n->env = NULL;
+    }
+  GNUNET_MQ_destroy(n->mq);
+  GNUNET_assert(NULL == n->mq);
+  GNUNET_assert(
     GNUNET_YES ==
-    GNUNET_CONTAINER_multipeermap_remove (handle->neighbours, key, n));
-  GNUNET_free (n);
+    GNUNET_CONTAINER_multipeermap_remove(handle->neighbours, key, n));
+  GNUNET_free(n);
   return GNUNET_YES;
 }
 
@@ -294,14 +291,14 @@ neighbour_delete (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
  * @param error error code
  */
 static void
-mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
+mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
 {
   struct GNUNET_TRANSPORT_CoreHandle *h = cls;
 
-  LOG (GNUNET_ERROR_TYPE_ERROR,
-       "Error receiving from transport service (%d), disconnecting temporarily.\n",
-       error);
-  disconnect_and_schedule_reconnect (h);
+  LOG(GNUNET_ERROR_TYPE_ERROR,
+      "Error receiving from transport service (%d), disconnecting temporarily.\n",
+      error);
+  disconnect_and_schedule_reconnect(h);
 }
 
 
@@ -313,16 +310,16 @@ mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
  * @return #GNUNET_OK if message is well-formed
  */
 static int
-check_hello (void *cls, const struct GNUNET_MessageHeader *msg)
+check_hello(void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_PeerIdentity me;
 
   if (GNUNET_OK !=
-      GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) msg, &me))
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+      GNUNET_HELLO_get_id((const struct GNUNET_HELLO_Message *)msg, &me))
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -334,7 +331,7 @@ check_hello (void *cls, const struct GNUNET_MessageHeader *msg)
  * @param msg message received
  */
 static void
-handle_hello (void *cls, const struct GNUNET_MessageHeader *msg)
+handle_hello(void *cls, const struct GNUNET_MessageHeader *msg)
 {
   /* we do not care => FIXME: signal in options to NEVER send HELLOs! */
 }
@@ -349,13 +346,13 @@ handle_hello (void *cls, const struct GNUNET_MessageHeader *msg)
  * @param cls the `struct Neighbour` where the message was sent
  */
 static void
-notify_send_done_fin (void *cls)
+notify_send_done_fin(void *cls)
 {
   struct Neighbour *n = cls;
 
   n->timeout_task = NULL;
   n->is_ready = GNUNET_YES;
-  GNUNET_MQ_impl_send_continue (n->mq);
+  GNUNET_MQ_impl_send_continue(n->mq);
 }
 
 
@@ -368,31 +365,31 @@ notify_send_done_fin (void *cls)
  * @param cls the `struct Neighbour` where the message was sent
  */
 static void
-notify_send_done (void *cls)
+notify_send_done(void *cls)
 {
   struct Neighbour *n = cls;
   struct GNUNET_TIME_Relative delay;
 
   n->timeout_task = NULL;
   if (NULL != n->env)
-  {
-    GNUNET_BANDWIDTH_tracker_consume (&n->out_tracker,
-                                      n->env_size + n->traffic_overhead);
-    n->env = NULL;
-    n->traffic_overhead = 0;
-  }
-  delay = GNUNET_BANDWIDTH_tracker_get_delay (&n->out_tracker, 128);
+    {
+      GNUNET_BANDWIDTH_tracker_consume(&n->out_tracker,
+                                       n->env_size + n->traffic_overhead);
+      n->env = NULL;
+      n->traffic_overhead = 0;
+    }
+  delay = GNUNET_BANDWIDTH_tracker_get_delay(&n->out_tracker, 128);
   if (0 == delay.rel_value_us)
-  {
-    n->is_ready = GNUNET_YES;
-    GNUNET_MQ_impl_send_continue (n->mq);
-    return;
-  }
-  GNUNET_MQ_impl_send_in_flight (n->mq);
+    {
+      n->is_ready = GNUNET_YES;
+      GNUNET_MQ_impl_send_continue(n->mq);
+      return;
+    }
+  GNUNET_MQ_impl_send_in_flight(n->mq);
   /* cannot send even a small message without violating
      quota, wait a before allowing MQ to send next message */
   n->timeout_task =
-    GNUNET_SCHEDULER_add_delayed (delay, &notify_send_done_fin, n);
+    GNUNET_SCHEDULER_add_delayed(delay, &notify_send_done_fin, n);
 }
 
 
@@ -407,44 +404,44 @@ notify_send_done (void *cls)
  * @param impl_state state of the implementation
  */
 static void
-mq_send_impl (struct GNUNET_MQ_Handle *mq,
-              const struct GNUNET_MessageHeader *msg,
-              void *impl_state)
+mq_send_impl(struct GNUNET_MQ_Handle *mq,
+             const struct GNUNET_MessageHeader *msg,
+             void *impl_state)
 {
   struct Neighbour *n = impl_state;
   struct GNUNET_TRANSPORT_CoreHandle *h = n->h;
   struct OutboundMessage *obm;
   uint16_t msize;
 
-  GNUNET_assert (GNUNET_YES == n->is_ready);
-  msize = ntohs (msg->size);
-  if (msize >= GNUNET_MAX_MESSAGE_SIZE - sizeof (*obm))
-  {
-    GNUNET_break (0);
-    GNUNET_MQ_impl_send_continue (mq);
-    return;
-  }
-  GNUNET_assert (NULL == n->env);
+  GNUNET_assert(GNUNET_YES == n->is_ready);
+  msize = ntohs(msg->size);
+  if (msize >= GNUNET_MAX_MESSAGE_SIZE - sizeof(*obm))
+    {
+      GNUNET_break(0);
+      GNUNET_MQ_impl_send_continue(mq);
+      return;
+    }
+  GNUNET_assert(NULL == n->env);
   n->env =
-    GNUNET_MQ_msg_nested_mh (obm, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, msg);
+    GNUNET_MQ_msg_nested_mh(obm, GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, msg);
   {
     struct GNUNET_MQ_Envelope *env;
 
-    env = GNUNET_MQ_get_current_envelope (mq);
-    obm->priority = htonl ((uint32_t) GNUNET_MQ_env_get_options (env));
+    env = GNUNET_MQ_get_current_envelope(mq);
+    obm->priority = htonl((uint32_t)GNUNET_MQ_env_get_options(env));
   }
-  obm->timeout = GNUNET_TIME_relative_hton (
+  obm->timeout = GNUNET_TIME_relative_hton(
     GNUNET_TIME_UNIT_MINUTES); /* FIXME: to be removed */
   obm->peer = n->id;
-  GNUNET_assert (NULL == n->timeout_task);
+  GNUNET_assert(NULL == n->timeout_task);
   n->is_ready = GNUNET_NO;
-  n->env_size = ntohs (msg->size);
-  GNUNET_MQ_notify_sent (n->env, &notify_send_done, n);
-  GNUNET_MQ_send (h->mq, n->env);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Queued message of type %u for neighbour `%s'.\n",
-       ntohs (msg->type),
-       GNUNET_i2s (&n->id));
+  n->env_size = ntohs(msg->size);
+  GNUNET_MQ_notify_sent(n->env, &notify_send_done, n);
+  GNUNET_MQ_send(h->mq, n->env);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Queued message of type %u for neighbour `%s'.\n",
+      ntohs(msg->type),
+      GNUNET_i2s(&n->id));
 }
 
 
@@ -456,11 +453,11 @@ mq_send_impl (struct GNUNET_MQ_Handle *mq,
  * @param impl_state state of the implementation
  */
 static void
-mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
+mq_destroy_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
 {
   struct Neighbour *n = impl_state;
 
-  GNUNET_assert (mq == n->mq);
+  GNUNET_assert(mq == n->mq);
   n->mq = NULL;
 }
 
@@ -473,16 +470,16 @@ mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
  * @param impl_state state specific to the implementation
  */
 static void
-mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
+mq_cancel_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
 {
   struct Neighbour *n = impl_state;
 
-  GNUNET_assert (GNUNET_NO == n->is_ready);
+  GNUNET_assert(GNUNET_NO == n->is_ready);
   if (NULL != n->env)
-  {
-    GNUNET_MQ_send_cancel (n->env);
-    n->env = NULL;
-  }
+    {
+      GNUNET_MQ_send_cancel(n->env);
+      n->env = NULL;
+    }
 
   n->is_ready = GNUNET_YES;
 }
@@ -497,11 +494,11 @@ mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
  * @param error error code
  */
 static void
-peer_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
+peer_mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
 {
   /* struct Neighbour *n = cls; */
 
-  GNUNET_break_op (0);
+  GNUNET_break_op(0);
 }
 
 
@@ -512,16 +509,16 @@ peer_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
  * @param cls the `struct Neighbour` for which the timeout changed
  */
 static void
-outbound_bw_tracker_update (void *cls)
+outbound_bw_tracker_update(void *cls)
 {
   struct Neighbour *n = cls;
   struct GNUNET_TIME_Relative delay;
 
   if (NULL == n->timeout_task)
     return;
-  delay = GNUNET_BANDWIDTH_tracker_get_delay (&n->out_tracker, 128);
-  GNUNET_SCHEDULER_cancel (n->timeout_task);
-  n->timeout_task = GNUNET_SCHEDULER_add_delayed (delay, &notify_send_done, n);
+  delay = GNUNET_BANDWIDTH_tracker_get_delay(&n->out_tracker, 128);
+  GNUNET_SCHEDULER_cancel(n->timeout_task);
+  n->timeout_task = GNUNET_SCHEDULER_add_delayed(delay, &notify_send_done, n);
 }
 
 
@@ -532,54 +529,54 @@ outbound_bw_tracker_update (void *cls)
  * @param cim message received
  */
 static void
-handle_connect (void *cls, const struct ConnectInfoMessage *cim)
+handle_connect(void *cls, const struct ConnectInfoMessage *cim)
 {
   struct GNUNET_TRANSPORT_CoreHandle *h = cls;
   struct Neighbour *n;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Receiving CONNECT message for `%s' with quota %u\n",
-       GNUNET_i2s (&cim->id),
-       ntohl (cim->quota_out.value__));
-  n = neighbour_find (h, &cim->id);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Receiving CONNECT message for `%s' with quota %u\n",
+      GNUNET_i2s(&cim->id),
+      ntohl(cim->quota_out.value__));
+  n = neighbour_find(h, &cim->id);
   if (NULL != n)
-  {
-    GNUNET_break (0); /* FIXME: this assertion seems to fail sometimes!? */
-    disconnect_and_schedule_reconnect (h);
-    return;
-  }
-  n = GNUNET_new (struct Neighbour);
+    {
+      GNUNET_break(0); /* FIXME: this assertion seems to fail sometimes!? */
+      disconnect_and_schedule_reconnect(h);
+      return;
+    }
+  n = GNUNET_new(struct Neighbour);
   n->id = cim->id;
   n->h = h;
   n->is_ready = GNUNET_YES;
   n->traffic_overhead = 0;
-  GNUNET_BANDWIDTH_tracker_init2 (&n->out_tracker,
-                                  &outbound_bw_tracker_update,
-                                  n,
-                                  GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
-                                  MAX_BANDWIDTH_CARRY_S,
-                                  &notify_excess_cb,
-                                  n);
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multipeermap_put (
-                   h->neighbours,
-                   &n->id,
-                   n,
-                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-
-  GNUNET_BANDWIDTH_tracker_update_quota (&n->out_tracker, cim->quota_out);
-  n->mq = GNUNET_MQ_queue_for_callbacks (&mq_send_impl,
-                                         &mq_destroy_impl,
-                                         &mq_cancel_impl,
-                                         n,
-                                         h->handlers,
-                                         &peer_mq_error_handler,
-                                         n);
+  GNUNET_BANDWIDTH_tracker_init2(&n->out_tracker,
+                                 &outbound_bw_tracker_update,
+                                 n,
+                                 GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
+                                 MAX_BANDWIDTH_CARRY_S,
+                                 &notify_excess_cb,
+                                 n);
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_CONTAINER_multipeermap_put(
+                  h->neighbours,
+                  &n->id,
+                  n,
+                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+
+  GNUNET_BANDWIDTH_tracker_update_quota(&n->out_tracker, cim->quota_out);
+  n->mq = GNUNET_MQ_queue_for_callbacks(&mq_send_impl,
+                                        &mq_destroy_impl,
+                                        &mq_cancel_impl,
+                                        n,
+                                        h->handlers,
+                                        &peer_mq_error_handler,
+                                        n);
   if (NULL != h->nc_cb)
-  {
-    n->handlers_cls = h->nc_cb (h->cls, &n->id, n->mq);
-    GNUNET_MQ_set_handlers_closure (n->mq, n->handlers_cls);
-  }
+    {
+      n->handlers_cls = h->nc_cb(h->cls, &n->id, n->mq);
+      GNUNET_MQ_set_handlers_closure(n->mq, n->handlers_cls);
+    }
 }
 
 
@@ -590,23 +587,23 @@ handle_connect (void *cls, const struct ConnectInfoMessage *cim)
  * @param dim message received
  */
 static void
-handle_disconnect (void *cls, const struct DisconnectInfoMessage *dim)
+handle_disconnect(void *cls, const struct DisconnectInfoMessage *dim)
 {
   struct GNUNET_TRANSPORT_CoreHandle *h = cls;
   struct Neighbour *n;
 
-  GNUNET_break (ntohl (dim->reserved) == 0);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Receiving DISCONNECT message for `%s'.\n",
-       GNUNET_i2s (&dim->peer));
-  n = neighbour_find (h, &dim->peer);
+  GNUNET_break(ntohl(dim->reserved) == 0);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Receiving DISCONNECT message for `%s'.\n",
+      GNUNET_i2s(&dim->peer));
+  n = neighbour_find(h, &dim->peer);
   if (NULL == n)
-  {
-    GNUNET_break (0);
-    disconnect_and_schedule_reconnect (h);
-    return;
-  }
-  GNUNET_assert (GNUNET_YES == neighbour_delete (h, &dim->peer, n));
+    {
+      GNUNET_break(0);
+      disconnect_and_schedule_reconnect(h);
+      return;
+    }
+  GNUNET_assert(GNUNET_YES == neighbour_delete(h, &dim->peer, n));
 }
 
 
@@ -617,36 +614,36 @@ handle_disconnect (void *cls, const struct DisconnectInfoMessage *dim)
  * @param okm message received
  */
 static void
-handle_send_ok (void *cls, const struct SendOkMessage *okm)
+handle_send_ok(void *cls, const struct SendOkMessage *okm)
 {
   struct GNUNET_TRANSPORT_CoreHandle *h = cls;
   struct Neighbour *n;
   uint32_t bytes_msg;
   uint32_t bytes_physical;
 
-  bytes_msg = ntohl (okm->bytes_msg);
-  bytes_physical = ntohl (okm->bytes_physical);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Receiving SEND_OK message, transmission to %s %s.\n",
-       GNUNET_i2s (&okm->peer),
-       ntohl (okm->success) == GNUNET_OK ? "succeeded" : "failed");
-  n = neighbour_find (h, &okm->peer);
+  bytes_msg = ntohl(okm->bytes_msg);
+  bytes_physical = ntohl(okm->bytes_physical);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Receiving SEND_OK message, transmission to %s %s.\n",
+      GNUNET_i2s(&okm->peer),
+      ntohl(okm->success) == GNUNET_OK ? "succeeded" : "failed");
+  n = neighbour_find(h, &okm->peer);
   if (NULL == n)
-  {
-    /* We should never get a 'SEND_OK' for a peer that we are not
-       connected to */
-    GNUNET_break (0);
-    disconnect_and_schedule_reconnect (h);
-    return;
-  }
+    {
+      /* We should never get a 'SEND_OK' for a peer that we are not
+         connected to */
+      GNUNET_break(0);
+      disconnect_and_schedule_reconnect(h);
+      return;
+    }
   if (bytes_physical > bytes_msg)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Overhead for %u byte message was %u\n",
-         bytes_msg,
-         bytes_physical - bytes_msg);
-    n->traffic_overhead += bytes_physical - bytes_msg;
-  }
+    {
+      LOG(GNUNET_ERROR_TYPE_DEBUG,
+          "Overhead for %u byte message was %u\n",
+          bytes_msg,
+          bytes_physical - bytes_msg);
+      n->traffic_overhead += bytes_physical - bytes_msg;
+    }
 }
 
 
@@ -657,23 +654,23 @@ handle_send_ok (void *cls, const struct SendOkMessage *okm)
  * @param im message received
  */
 static int
-check_recv (void *cls, const struct InboundMessage *im)
+check_recv(void *cls, const struct InboundMessage *im)
 {
   const struct GNUNET_MessageHeader *imm;
   uint16_t size;
 
-  size = ntohs (im->header.size) - sizeof (*im);
-  if (size < sizeof (struct GNUNET_MessageHeader))
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  imm = (const struct GNUNET_MessageHeader *) &im[1];
-  if (ntohs (imm->size) != size)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
+  size = ntohs(im->header.size) - sizeof(*im);
+  if (size < sizeof(struct GNUNET_MessageHeader))
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
+  imm = (const struct GNUNET_MessageHeader *)&im[1];
+  if (ntohs(imm->size) != size)
+    {
+      GNUNET_break(0);
+      return GNUNET_SYSERR;
+    }
   return GNUNET_OK;
 }
 
@@ -685,27 +682,27 @@ check_recv (void *cls, const struct InboundMessage *im)
  * @param im message received
  */
 static void
-handle_recv (void *cls, const struct InboundMessage *im)
+handle_recv(void *cls, const struct InboundMessage *im)
 {
   struct GNUNET_TRANSPORT_CoreHandle *h = cls;
   const struct GNUNET_MessageHeader *imm =
-    (const struct GNUNET_MessageHeader *) &im[1];
+    (const struct GNUNET_MessageHeader *)&im[1];
   struct Neighbour *n;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Received message of type %u with %u bytes from `%s'.\n",
-       (unsigned int) ntohs (imm->type),
-       (unsigned int) ntohs (imm->size),
-       GNUNET_i2s (&im->peer));
-  n = neighbour_find (h, &im->peer);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Received message of type %u with %u bytes from `%s'.\n",
+      (unsigned int)ntohs(imm->type),
+      (unsigned int)ntohs(imm->size),
+      GNUNET_i2s(&im->peer));
+  n = neighbour_find(h, &im->peer);
   if (NULL == n)
-  {
-    GNUNET_break (0);
-    disconnect_and_schedule_reconnect (h);
-    return;
-  }
+    {
+      GNUNET_break(0);
+      disconnect_and_schedule_reconnect(h);
+      return;
+    }
   h->rom_pending++;
-  GNUNET_MQ_inject_message (n->mq, imm);
+  GNUNET_MQ_inject_message(n->mq, imm);
 }
 
 
@@ -716,24 +713,24 @@ handle_recv (void *cls, const struct InboundMessage *im)
  * @param msg message received
  */
 static void
-handle_set_quota (void *cls, const struct QuotaSetMessage *qm)
+handle_set_quota(void *cls, const struct QuotaSetMessage *qm)
 {
   struct GNUNET_TRANSPORT_CoreHandle *h = cls;
   struct Neighbour *n;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Receiving SET_QUOTA message for `%s' with quota %u\n",
-       GNUNET_i2s (&qm->peer),
-       ntohl (qm->quota.value__));
-  n = neighbour_find (h, &qm->peer);
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Receiving SET_QUOTA message for `%s' with quota %u\n",
+      GNUNET_i2s(&qm->peer),
+      ntohl(qm->quota.value__));
+  n = neighbour_find(h, &qm->peer);
   if (NULL == n)
-  {
-    GNUNET_break (
-      0); /* FIXME: julius reports this assertion fails sometimes? */
-    disconnect_and_schedule_reconnect (h);
-    return;
-  }
-  GNUNET_BANDWIDTH_tracker_update_quota (&n->out_tracker, qm->quota);
+    {
+      GNUNET_break(
+        0); /* FIXME: julius reports this assertion fails sometimes? */
+      disconnect_and_schedule_reconnect(h);
+      return;
+    }
+  GNUNET_BANDWIDTH_tracker_update_quota(&n->out_tracker, qm->quota);
 }
 
 
@@ -743,55 +740,55 @@ handle_set_quota (void *cls, const struct QuotaSetMessage *qm)
  * @param cls the handle to the transport service
  */
 static void
-reconnect (void *cls)
+reconnect(void *cls)
 {
   struct GNUNET_TRANSPORT_CoreHandle *h = cls;
   struct GNUNET_MQ_MessageHandler handlers[] =
-    {GNUNET_MQ_hd_var_size (hello,
-                            GNUNET_MESSAGE_TYPE_HELLO,
-                            struct GNUNET_MessageHeader,
+  { GNUNET_MQ_hd_var_size(hello,
+                          GNUNET_MESSAGE_TYPE_HELLO,
+                          struct GNUNET_MessageHeader,
+                          h),
+    GNUNET_MQ_hd_fixed_size(connect,
+                            GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT,
+                            struct ConnectInfoMessage,
+                            h),
+    GNUNET_MQ_hd_fixed_size(disconnect,
+                            GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT,
+                            struct DisconnectInfoMessage,
                             h),
-     GNUNET_MQ_hd_fixed_size (connect,
-                              GNUNET_MESSAGE_TYPE_TRANSPORT_CONNECT,
-                              struct ConnectInfoMessage,
-                              h),
-     GNUNET_MQ_hd_fixed_size (disconnect,
-                              GNUNET_MESSAGE_TYPE_TRANSPORT_DISCONNECT,
-                              struct DisconnectInfoMessage,
-                              h),
-     GNUNET_MQ_hd_fixed_size (send_ok,
-                              GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK,
-                              struct SendOkMessage,
-                              h),
-     GNUNET_MQ_hd_var_size (recv,
-                            GNUNET_MESSAGE_TYPE_TRANSPORT_RECV,
-                            struct InboundMessage,
+    GNUNET_MQ_hd_fixed_size(send_ok,
+                            GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_OK,
+                            struct SendOkMessage,
                             h),
-     GNUNET_MQ_hd_fixed_size (set_quota,
-                              GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA,
-                              struct QuotaSetMessage,
-                              h),
-     GNUNET_MQ_handler_end ()};
+    GNUNET_MQ_hd_var_size(recv,
+                          GNUNET_MESSAGE_TYPE_TRANSPORT_RECV,
+                          struct InboundMessage,
+                          h),
+    GNUNET_MQ_hd_fixed_size(set_quota,
+                            GNUNET_MESSAGE_TYPE_TRANSPORT_SET_QUOTA,
+                            struct QuotaSetMessage,
+                            h),
+    GNUNET_MQ_handler_end() };
   struct GNUNET_MQ_Envelope *env;
   struct StartMessage *s;
   uint32_t options;
 
   h->reconnect_task = NULL;
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service.\n");
-  GNUNET_assert (NULL == h->mq);
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service.\n");
+  GNUNET_assert(NULL == h->mq);
   h->mq =
-    GNUNET_CLIENT_connect (h->cfg, "transport", handlers, &mq_error_handler, h);
+    GNUNET_CLIENT_connect(h->cfg, "transport", handlers, &mq_error_handler, h);
   if (NULL == h->mq)
     return;
-  env = GNUNET_MQ_msg (s, GNUNET_MESSAGE_TYPE_TRANSPORT_START);
+  env = GNUNET_MQ_msg(s, GNUNET_MESSAGE_TYPE_TRANSPORT_START);
   options = 0;
   if (h->check_self)
     options |= 1;
   if (NULL != h->handlers)
     options |= 2;
-  s->options = htonl (options);
+  s->options = htonl(options);
   s->self = h->self;
-  GNUNET_MQ_send (h->mq, env);
+  GNUNET_MQ_send(h->mq, env);
 }
 
 
@@ -802,22 +799,22 @@ reconnect (void *cls)
  * @param h transport service to reconnect
  */
 static void
-disconnect_and_schedule_reconnect (struct GNUNET_TRANSPORT_CoreHandle *h)
+disconnect_and_schedule_reconnect(struct GNUNET_TRANSPORT_CoreHandle *h)
 {
-  GNUNET_assert (NULL == h->reconnect_task);
+  GNUNET_assert(NULL == h->reconnect_task);
   /* Forget about all neighbours that we used to be connected to */
-  GNUNET_CONTAINER_multipeermap_iterate (h->neighbours, &neighbour_delete, h);
+  GNUNET_CONTAINER_multipeermap_iterate(h->neighbours, &neighbour_delete, h);
   if (NULL != h->mq)
-  {
-    GNUNET_MQ_destroy (h->mq);
-    h->mq = NULL;
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Scheduling task to reconnect to transport service in %s.\n",
-       GNUNET_STRINGS_relative_time_to_string (h->reconnect_delay, GNUNET_YES));
+    {
+      GNUNET_MQ_destroy(h->mq);
+      h->mq = NULL;
+    }
+  LOG(GNUNET_ERROR_TYPE_DEBUG,
+      "Scheduling task to reconnect to transport service in %s.\n",
+      GNUNET_STRINGS_relative_time_to_string(h->reconnect_delay, GNUNET_YES));
   h->reconnect_task =
-    GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
-  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
+    GNUNET_SCHEDULER_add_delayed(h->reconnect_delay, &reconnect, h);
+  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF(h->reconnect_delay);
 }
 
 
@@ -829,12 +826,12 @@ disconnect_and_schedule_reconnect (struct GNUNET_TRANSPORT_CoreHandle *h)
  * @return NULL if disconnected, otherwise message queue for @a peer
  */
 struct GNUNET_MQ_Handle *
-GNUNET_TRANSPORT_core_get_mq (struct GNUNET_TRANSPORT_CoreHandle *handle,
-                              const struct GNUNET_PeerIdentity *peer)
+GNUNET_TRANSPORT_core_get_mq(struct GNUNET_TRANSPORT_CoreHandle *handle,
+                             const struct GNUNET_PeerIdentity *peer)
 {
   struct Neighbour *n;
 
-  n = neighbour_find (handle, peer);
+  n = neighbour_find(handle, peer);
   if (NULL == n)
     return NULL;
   return n->mq;
@@ -856,23 +853,23 @@ GNUNET_TRANSPORT_core_get_mq (struct GNUNET_TRANSPORT_CoreHandle *handle,
  * @return NULL on error
  */
 struct GNUNET_TRANSPORT_CoreHandle *
-GNUNET_TRANSPORT_core_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                               const struct GNUNET_PeerIdentity *self,
-                               const struct GNUNET_MQ_MessageHandler *handlers,
-                               void *cls,
-                               GNUNET_TRANSPORT_NotifyConnect nc,
-                               GNUNET_TRANSPORT_NotifyDisconnect nd,
-                               GNUNET_TRANSPORT_NotifyExcessBandwidth neb)
+GNUNET_TRANSPORT_core_connect(const struct GNUNET_CONFIGURATION_Handle *cfg,
+                              const struct GNUNET_PeerIdentity *self,
+                              const struct GNUNET_MQ_MessageHandler *handlers,
+                              void *cls,
+                              GNUNET_TRANSPORT_NotifyConnect nc,
+                              GNUNET_TRANSPORT_NotifyDisconnect nd,
+                              GNUNET_TRANSPORT_NotifyExcessBandwidth neb)
 {
   struct GNUNET_TRANSPORT_CoreHandle *h;
   unsigned int i;
 
-  h = GNUNET_new (struct GNUNET_TRANSPORT_CoreHandle);
+  h = GNUNET_new(struct GNUNET_TRANSPORT_CoreHandle);
   if (NULL != self)
-  {
-    h->self = *self;
-    h->check_self = GNUNET_YES;
-  }
+    {
+      h->self = *self;
+      h->check_self = GNUNET_YES;
+    }
   h->cfg = cfg;
   h->cls = cls;
   h->nc_cb = nc;
@@ -880,24 +877,24 @@ GNUNET_TRANSPORT_core_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
   h->neb_cb = neb;
   h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
   if (NULL != handlers)
-  {
-    for (i = 0; NULL != handlers[i].cb; i++)
-      ;
-    h->handlers = GNUNET_new_array (i + 1, struct GNUNET_MQ_MessageHandler);
-    GNUNET_memcpy (h->handlers,
-                   handlers,
-                   i * sizeof (struct GNUNET_MQ_MessageHandler));
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service\n");
-  reconnect (h);
+    {
+      for (i = 0; NULL != handlers[i].cb; i++)
+        ;
+      h->handlers = GNUNET_new_array(i + 1, struct GNUNET_MQ_MessageHandler);
+      GNUNET_memcpy(h->handlers,
+                    handlers,
+                    i * sizeof(struct GNUNET_MQ_MessageHandler));
+    }
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service\n");
+  reconnect(h);
   if (NULL == h->mq)
-  {
-    GNUNET_free_non_null (h->handlers);
-    GNUNET_free (h);
-    return NULL;
-  }
+    {
+      GNUNET_free_non_null(h->handlers);
+      GNUNET_free(h);
+      return NULL;
+    }
   h->neighbours =
-    GNUNET_CONTAINER_multipeermap_create (STARTING_NEIGHBOURS_SIZE, GNUNET_YES);
+    GNUNET_CONTAINER_multipeermap_create(STARTING_NEIGHBOURS_SIZE, GNUNET_YES);
   return h;
 }
 
@@ -909,23 +906,23 @@ GNUNET_TRANSPORT_core_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * #GNUNET_TRANSPORT_core_connect()
  */
 void
-GNUNET_TRANSPORT_core_disconnect (struct GNUNET_TRANSPORT_CoreHandle *handle)
+GNUNET_TRANSPORT_core_disconnect(struct GNUNET_TRANSPORT_CoreHandle *handle)
 {
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Transport disconnect called!\n");
+  LOG(GNUNET_ERROR_TYPE_DEBUG, "Transport disconnect called!\n");
   /* this disconnects all neighbours... */
   if (NULL == handle->reconnect_task)
-    disconnect_and_schedule_reconnect (handle);
+    disconnect_and_schedule_reconnect(handle);
   /* and now we stop trying to connect again... */
   if (NULL != handle->reconnect_task)
-  {
-    GNUNET_SCHEDULER_cancel (handle->reconnect_task);
-    handle->reconnect_task = NULL;
-  }
-  GNUNET_CONTAINER_multipeermap_destroy (handle->neighbours);
+    {
+      GNUNET_SCHEDULER_cancel(handle->reconnect_task);
+      handle->reconnect_task = NULL;
+    }
+  GNUNET_CONTAINER_multipeermap_destroy(handle->neighbours);
   handle->neighbours = NULL;
-  GNUNET_free_non_null (handle->handlers);
+  GNUNET_free_non_null(handle->handlers);
   handle->handlers = NULL;
-  GNUNET_free (handle);
+  GNUNET_free(handle);
 }
 
 
@@ -950,18 +947,18 @@ GNUNET_TRANSPORT_core_disconnect (struct GNUNET_TRANSPORT_CoreHandle *handle)
  * @param pid which peer was the message from that was fully processed by CORE
  */
 void
-GNUNET_TRANSPORT_core_receive_continue (struct GNUNET_TRANSPORT_CoreHandle *ch,
-                                        const struct GNUNET_PeerIdentity *pid)
+GNUNET_TRANSPORT_core_receive_continue(struct GNUNET_TRANSPORT_CoreHandle *ch,
+                                       const struct GNUNET_PeerIdentity *pid)
 {
   struct RecvOkMessage *rom;
   struct GNUNET_MQ_Envelope *env;
 
-  GNUNET_assert (ch->rom_pending > 0);
+  GNUNET_assert(ch->rom_pending > 0);
   ch->rom_pending--;
-  env = GNUNET_MQ_msg (rom, GNUNET_MESSAGE_TYPE_TRANSPORT_RECV_OK);
-  rom->increase_window_delta = htonl (1);
+  env = GNUNET_MQ_msg(rom, GNUNET_MESSAGE_TYPE_TRANSPORT_RECV_OK);
+  rom->increase_window_delta = htonl(1);
   rom->peer = *pid;
-  GNUNET_MQ_send (ch->mq, env);
+  GNUNET_MQ_send(ch->mq, env);
 }