1 files changed, 248 insertions, 250 deletions

diff --git a/src/mesh/mesh_api_new.c b/src/mesh/mesh_api_new.c
index 0540c765b..e6e6fdaa8 100644
--- a/src/mesh/mesh_api_new.c
+++ b/src/mesh/mesh_api_new.c
@@ -22,7 +22,7 @@
  * @file mesh/mesh_api_new.c
  * @brief mesh api: client implementation of mesh service
  * @author Bartlomiej Polot
- * 
+ *
  * STRUCTURE:
  * - CONSTANTS
  * - DATA STRUCTURES
@@ -193,7 +193,7 @@ retrieve_tunnel (struct GNUNET_MESH_Handle *h, MESH_TunnelNumber tid)
 
 /**
  * Process the new tunnel notification and add it to the tunnels in the handle
- * 
+ *
  * @param h     The mesh handle
  * @param msg   A message with the details of the new incoming tunnel
  */
@@ -201,30 +201,30 @@ static void
 process_tunnel_create (struct GNUNET_MESH_Handle *h,
                        const struct GNUNET_MESH_TunnelMessage *msg)
 {
-    struct GNUNET_MESH_Tunnel *t;
-    MESH_TunnelNumber tid;
+  struct GNUNET_MESH_Tunnel *t;
+  MESH_TunnelNumber tid;
 
-    tid = ntohl (msg->tunnel_id);
-    if (tid >= GNUNET_MESH_LOCAL_TUNNEL_ID_MARK)
-    {
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "MESH: received an incoming tunnel with tid in local range (%X)\n",
-                    tid);
-                    GNUNET_break_op (0);
-                    return;                     //FIXME abort? reconnect?
-    }
-    t = GNUNET_malloc (sizeof (struct GNUNET_MESH_Tunnel));
-    t->cls = h->cls;
-    t->mesh = h;
-    t->tid = tid;
+  tid = ntohl (msg->tunnel_id);
+  if (tid >= GNUNET_MESH_LOCAL_TUNNEL_ID_MARK)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "MESH: received an incoming tunnel with tid in local range (%X)\n",
+                tid);
+    GNUNET_break_op (0);
+    return;                     //FIXME abort? reconnect?
+  }
+  t = GNUNET_malloc (sizeof (struct GNUNET_MESH_Tunnel));
+  t->cls = h->cls;
+  t->mesh = h;
+  t->tid = tid;
 
-    return;
+  return;
 }
 
 
 /**
  * Process the new peer event and notify the upper level of it
- * 
+ *
  * @param h     The mesh handle
  * @param msg   A message with the details of the peer event
  */
@@ -232,41 +232,41 @@ static void
 process_peer_event (struct GNUNET_MESH_Handle *h,
                     const struct GNUNET_MESH_PeerControl *msg)
 {
-    struct GNUNET_MESH_Tunnel *t;
-    uint16_t size;
+  struct GNUNET_MESH_Tunnel *t;
+  uint16_t size;
 
-    size = ntohs (msg->header.size);
-    if (size != sizeof (struct GNUNET_MESH_PeerControl))
-    {
-        GNUNET_break_op (0);
-        return;
-    }
-    t = retrieve_tunnel (h, ntohl (msg->tunnel_id));
-    if (NULL == t)
-    {
-        GNUNET_break_op (0);
-        return;
-    }
-    if (GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_CONNECTED == msg->header.type)
+  size = ntohs (msg->header.size);
+  if (size != sizeof (struct GNUNET_MESH_PeerControl))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  t = retrieve_tunnel (h, ntohl (msg->tunnel_id));
+  if (NULL == t)
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  if (GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_CONNECTED == msg->header.type)
+  {
+    if (NULL != t->connect_handler)
     {
-        if (NULL != t->connect_handler)
-        {
-            t->connect_handler (t->cls, &msg->peer, NULL);    /* FIXME atsi */
-        }
+      t->connect_handler (t->cls, &msg->peer, NULL);    /* FIXME atsi */
     }
-    else
+  }
+  else
+  {
+    if (NULL != t->disconnect_handler)
     {
-        if (NULL != t->disconnect_handler)
-        {
-            t->disconnect_handler (t->cls, &msg->peer);
-        }
+      t->disconnect_handler (t->cls, &msg->peer);
     }
+  }
 }
 
 
 /**
  * Process the incoming data packets
- * 
+ *
  * @param h     The mesh handle
  * @param msh   A message encapsulating the data
  */
@@ -274,66 +274,66 @@ static void
 process_incoming_data (struct GNUNET_MESH_Handle *h,
                        const struct GNUNET_MessageHeader *message)
 {
-    const struct GNUNET_MessageHeader *payload;
-    const struct GNUNET_MESH_MessageHandler *handler;
-    const struct GNUNET_PeerIdentity *peer;
-    struct GNUNET_MESH_Unicast *ucast;
-    struct GNUNET_MESH_Multicast *mcast;
-    struct GNUNET_MESH_ToOrigin *to_orig;
-    struct GNUNET_MESH_Tunnel *t;
-    uint16_t type;
-    int i;
-
-    type = ntohs (message->type);
-    switch (type)
-    {
-        case GNUNET_MESSAGE_TYPE_MESH_UNICAST:
-            ucast = (struct GNUNET_MESH_Unicast *) message;
-            t = retrieve_tunnel (h, ntohl (ucast->tid));
-            payload = (struct GNUNET_MessageHeader *) &ucast[1];
-            peer = &ucast->oid;
-            break;
-        case GNUNET_MESSAGE_TYPE_MESH_MULTICAST:
-            mcast = (struct GNUNET_MESH_Multicast *) message;
-            t = retrieve_tunnel (h, ntohl (mcast->tid));
-            payload = (struct GNUNET_MessageHeader *) &mcast[1];
-            peer = &mcast->oid;
-            break;
-        case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
-            to_orig = (struct GNUNET_MESH_ToOrigin *) message;
-            t = retrieve_tunnel (h, ntohl (to_orig->tid));
-            payload = (struct GNUNET_MessageHeader *) &to_orig[1];
-            peer = &to_orig->sender;
-            break;
-        default:
-            GNUNET_break_op (0);
-            return;
-    }
-    if (NULL == t)
-    {
-        GNUNET_break_op (0);
-        return;
-    }
-    for (i = 0; i < h->n_handlers; i++)
+  const struct GNUNET_MessageHeader *payload;
+  const struct GNUNET_MESH_MessageHandler *handler;
+  const struct GNUNET_PeerIdentity *peer;
+  struct GNUNET_MESH_Unicast *ucast;
+  struct GNUNET_MESH_Multicast *mcast;
+  struct GNUNET_MESH_ToOrigin *to_orig;
+  struct GNUNET_MESH_Tunnel *t;
+  uint16_t type;
+  int i;
+
+  type = ntohs (message->type);
+  switch (type)
+  {
+  case GNUNET_MESSAGE_TYPE_MESH_UNICAST:
+    ucast = (struct GNUNET_MESH_Unicast *) message;
+    t = retrieve_tunnel (h, ntohl (ucast->tid));
+    payload = (struct GNUNET_MessageHeader *) &ucast[1];
+    peer = &ucast->oid;
+    break;
+  case GNUNET_MESSAGE_TYPE_MESH_MULTICAST:
+    mcast = (struct GNUNET_MESH_Multicast *) message;
+    t = retrieve_tunnel (h, ntohl (mcast->tid));
+    payload = (struct GNUNET_MessageHeader *) &mcast[1];
+    peer = &mcast->oid;
+    break;
+  case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
+    to_orig = (struct GNUNET_MESH_ToOrigin *) message;
+    t = retrieve_tunnel (h, ntohl (to_orig->tid));
+    payload = (struct GNUNET_MessageHeader *) &to_orig[1];
+    peer = &to_orig->sender;
+    break;
+  default:
+    GNUNET_break_op (0);
+    return;
+  }
+  if (NULL == t)
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  for (i = 0; i < h->n_handlers; i++)
+  {
+    handler = &h->message_handlers[i];
+    if (handler->type == type)
     {
-        handler = &h->message_handlers[i];
-        if (handler->type == type)
-        {
-            if (GNUNET_OK == handler->callback (h->cls, t, NULL,      /* FIXME ctx */
-                peer, payload, NULL)) /* FIXME atsi */
-            {
-                GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                            "MESH: callback completed successfully\n");
-            }
-            else
-            {
-                GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                            "MESH: callback caused disconnection\n");
-                GNUNET_MESH_disconnect (h);
-            }
-        }
+      if (GNUNET_OK == handler->callback (h->cls, t, NULL,      /* FIXME ctx */
+                                          peer, payload, NULL)) /* FIXME atsi */
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "MESH: callback completed successfully\n");
+      }
+      else
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "MESH: callback caused disconnection\n");
+        GNUNET_MESH_disconnect (h);
+      }
     }
-    return;
+  }
+  return;
 }
 
 
@@ -346,44 +346,43 @@ process_incoming_data (struct GNUNET_MESH_Handle *h,
 static void
 msg_received (void *cls, const struct GNUNET_MessageHeader *msg)
 {
-    struct GNUNET_MESH_Handle *h = cls;
+  struct GNUNET_MESH_Handle *h = cls;
 
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "mesh: received a message from MESH\n");
-    if (msg == NULL)
-    {
-        GNUNET_break_op (0);
-        return;
-    }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: received a message from MESH\n");
+  if (msg == NULL)
+  {
+    GNUNET_break_op (0);
+    return;
+  }
 
-    switch (ntohs (msg->type))
-    {
-        /* Notify of a new incoming tunnel */
-        case GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_CREATE:
-            process_tunnel_create (h, (struct GNUNET_MESH_TunnelMessage *) msg);
-            break;
-            /* Notify of a new peer or a peer disconnect in the tunnel */
-            case GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_CONNECTED:
-            case GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_DISCONNECTED:
-                process_peer_event (h, (struct GNUNET_MESH_PeerControl *) msg);
-                break;
-                /* Notify of a new data packet in the tunnel */
-                case GNUNET_MESSAGE_TYPE_MESH_UNICAST:
-                case GNUNET_MESSAGE_TYPE_MESH_MULTICAST:
-                case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
-                    process_incoming_data (h, msg);
-                    break;
-                    /* We shouldn't get any other packages, log and ignore */
-                    default:
-                        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                                    "MESH: unsolicited message form service (type %d)\n",
-                                    ntohs (msg->type));
-    }
+  switch (ntohs (msg->type))
+  {
+    /* Notify of a new incoming tunnel */
+  case GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_CREATE:
+    process_tunnel_create (h, (struct GNUNET_MESH_TunnelMessage *) msg);
+    break;
+    /* Notify of a new peer or a peer disconnect in the tunnel */
+  case GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_CONNECTED:
+  case GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_DISCONNECTED:
+    process_peer_event (h, (struct GNUNET_MESH_PeerControl *) msg);
+    break;
+    /* Notify of a new data packet in the tunnel */
+  case GNUNET_MESSAGE_TYPE_MESH_UNICAST:
+  case GNUNET_MESSAGE_TYPE_MESH_MULTICAST:
+  case GNUNET_MESSAGE_TYPE_MESH_TO_ORIGIN:
+    process_incoming_data (h, msg);
+    break;
+    /* We shouldn't get any other packages, log and ignore */
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "MESH: unsolicited message form service (type %d)\n",
+                ntohs (msg->type));
+  }
 
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: message processed\n");
-    GNUNET_CLIENT_receive (h->client, &msg_received, h,
-                           GNUNET_TIME_UNIT_FOREVER_REL);
-    return;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: message processed\n");
+  GNUNET_CLIENT_receive (h->client, &msg_received, h,
+                         GNUNET_TIME_UNIT_FOREVER_REL);
+  return;
 }
 
 
@@ -406,66 +405,65 @@ msg_received (void *cls, const struct GNUNET_MessageHeader *msg)
 static size_t
 send_connect_packet (void *cls, size_t size, void *buf)
 {
-    struct GNUNET_MESH_Handle           *h = cls;
-    struct GNUNET_MESH_ClientConnect    *msg;
-    GNUNET_MESH_ApplicationType         *apps;
-    uint16_t                            napps;
-    uint16_t                            *types;
-    uint16_t                            ntypes;
-
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "mesh: Send connect packet()\n", size);
-    h->th = NULL;
-    if (0 == size || NULL == buf)
-    {
-        // FIXME: disconnect, reconnect, retry?
-        return 0;
-    }
-    if (sizeof (struct GNUNET_MessageHeader) > size)
-    {
-        GNUNET_break(0);
-        // FIXME: disconnect, reconnect, retry!
-        return 0;
-    }
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "mesh: Send connect packet: %lu bytes buffer\n", size);
-    msg = (struct GNUNET_MESH_ClientConnect *) buf;
-    msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT);
-
-    for (ntypes = 0, types = NULL; ntypes < h->n_handlers; ntypes++)
-    {
-        types = GNUNET_realloc (types, sizeof (uint16_t) * (ntypes + 1));
-        types[ntypes] = h->message_handlers[ntypes].type;
-    }
+  struct GNUNET_MESH_Handle *h = cls;
+  struct GNUNET_MESH_ClientConnect *msg;
+  GNUNET_MESH_ApplicationType *apps;
+  uint16_t napps;
+  uint16_t *types;
+  uint16_t ntypes;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: Send connect packet()\n", size);
+  h->th = NULL;
+  if (0 == size || NULL == buf)
+  {
+    // FIXME: disconnect, reconnect, retry?
+    return 0;
+  }
+  if (sizeof (struct GNUNET_MessageHeader) > size)
+  {
+    GNUNET_break (0);
+    // FIXME: disconnect, reconnect, retry!
+    return 0;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "mesh: Send connect packet: %lu bytes buffer\n", size);
+  msg = (struct GNUNET_MESH_ClientConnect *) buf;
+  msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_CONNECT);
 
-    for (napps = 0, apps = NULL; napps < h->n_applications; napps++)
-    {
-        apps =
-            GNUNET_realloc (apps,
-                            sizeof (GNUNET_MESH_ApplicationType) * (napps + 1));
-        apps[napps] = h->applications[napps];
-    }
+  for (ntypes = 0, types = NULL; ntypes < h->n_handlers; ntypes++)
+  {
+    types = GNUNET_realloc (types, sizeof (uint16_t) * (ntypes + 1));
+    types[ntypes] = h->message_handlers[ntypes].type;
+  }
 
-    msg->header.size =
-        htons (sizeof (struct GNUNET_MESH_ClientConnect) +
-                sizeof (uint16_t) * ntypes +
-                sizeof (GNUNET_MESH_ApplicationType) * napps);
-    memcpy (&msg[1], types, sizeof (uint16_t) * ntypes);
-    types = (uint16_t *) &msg[1];
-    memcpy (&types[ntypes], apps, sizeof (GNUNET_MESH_ApplicationType) * napps);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "mesh: Sent %lu bytes long message %d types and %d apps\n",
-                ntohs (msg->header.size), ntypes, napps);
-    msg->applications = htons (napps);
-    msg->types = htons (ntypes);
-
-    /* start listening */
-    GNUNET_CLIENT_receive (h->client, &msg_received, h,
-                           GNUNET_TIME_UNIT_FOREVER_REL);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "mesh: Send connect packet() END\n", size);
+  for (napps = 0, apps = NULL; napps < h->n_applications; napps++)
+  {
+    apps =
+        GNUNET_realloc (apps,
+                        sizeof (GNUNET_MESH_ApplicationType) * (napps + 1));
+    apps[napps] = h->applications[napps];
+  }
 
-    return ntohs (msg->header.size);
+  msg->header.size =
+      htons (sizeof (struct GNUNET_MESH_ClientConnect) +
+             sizeof (uint16_t) * ntypes +
+             sizeof (GNUNET_MESH_ApplicationType) * napps);
+  memcpy (&msg[1], types, sizeof (uint16_t) * ntypes);
+  types = (uint16_t *) & msg[1];
+  memcpy (&types[ntypes], apps, sizeof (GNUNET_MESH_ApplicationType) * napps);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "mesh: Sent %lu bytes long message %d types and %d apps\n",
+              ntohs (msg->header.size), ntypes, napps);
+  msg->applications = htons (napps);
+  msg->types = htons (ntypes);
+
+  /* start listening */
+  GNUNET_CLIENT_receive (h->client, &msg_received, h,
+                         GNUNET_TIME_UNIT_FOREVER_REL);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: Send connect packet() END\n",
+              size);
+
+  return ntohs (msg->header.size);
 }
 
 
@@ -496,7 +494,7 @@ send_tunnel_create_packet (void *cls, size_t size, void *buf)
   }
   if (sizeof (struct GNUNET_MESH_TunnelMessage) > size)
   {
-    GNUNET_break(0);
+    GNUNET_break (0);
     // FIXME: disconnect, reconnect, retry?
     return 0;
   }
@@ -529,35 +527,35 @@ send_tunnel_create_packet (void *cls, size_t size, void *buf)
 static size_t
 send_tunnel_destroy_packet (void *cls, size_t size, void *buf)
 {
-    struct GNUNET_MESH_Tunnel           *t = cls;
-    struct GNUNET_MESH_Handle           *h;
-    struct GNUNET_MESH_TunnelMessage    *msg;
+  struct GNUNET_MESH_Tunnel *t = cls;
+  struct GNUNET_MESH_Handle *h;
+  struct GNUNET_MESH_TunnelMessage *msg;
 
-    h = t->mesh;
-    h->th = NULL;
-    if (0 == size || buf == NULL)
-    {
-        return 0;
-    }
-    if (sizeof (struct GNUNET_MESH_TunnelMessage) > size)
-    {
-        GNUNET_break(0);
-        // FIXME: disconnect, reconnect, retry!
-        return 0;
-    }
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Send tunnel destroy packet: %lu bytes buffer\n", size);
-    msg = (struct GNUNET_MESH_TunnelMessage *) buf;
-    msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_DESTROY);
+  h = t->mesh;
+  h->th = NULL;
+  if (0 == size || buf == NULL)
+  {
+    return 0;
+  }
+  if (sizeof (struct GNUNET_MESH_TunnelMessage) > size)
+  {
+    GNUNET_break (0);
+    // FIXME: disconnect, reconnect, retry!
+    return 0;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Send tunnel destroy packet: %lu bytes buffer\n", size);
+  msg = (struct GNUNET_MESH_TunnelMessage *) buf;
+  msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_TUNNEL_DESTROY);
 
-    msg->header.size = htons (sizeof (struct GNUNET_MESH_TunnelMessage));
-    msg->tunnel_id = htonl (t->tid);
+  msg->header.size = htons (sizeof (struct GNUNET_MESH_TunnelMessage));
+  msg->tunnel_id = htonl (t->tid);
 
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sent %lu bytes long message\n",
-                ntohs (msg->header.size));
-    GNUNET_free(t);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sent %lu bytes long message\n",
+              ntohs (msg->header.size));
+  GNUNET_free (t);
 
-    return sizeof (struct GNUNET_MESH_TunnelMessage);
+  return sizeof (struct GNUNET_MESH_TunnelMessage);
 }
 
 
@@ -577,7 +575,7 @@ send_tunnel_destroy_packet (void *cls, size_t size, void *buf)
  *                 inbound messages if the client does not process them fast
  *                 enough (for this notification type, a bounded queue is used)
  * @param stypes Application Types the client claims to offer
- * @return handle to the mesh service 
+ * @return handle to the mesh service
  *         NULL on error (in this case, init is never called)
  */
 struct GNUNET_MESH_Handle *
@@ -586,8 +584,8 @@ GNUNET_MESH_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls,
                      const struct GNUNET_MESH_MessageHandler *handlers,
                      const GNUNET_MESH_ApplicationType *stypes)
 {
-  struct GNUNET_MESH_Handle     *h;
-  size_t                        size;
+  struct GNUNET_MESH_Handle *h;
+  size_t size;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: GNUNET_MESH_connect()\n");
   h = GNUNET_malloc (sizeof (struct GNUNET_MESH_Handle));
@@ -596,7 +594,7 @@ GNUNET_MESH_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls,
   h->client = GNUNET_CLIENT_connect ("mesh", cfg);
   if (h->client == NULL)
   {
-    GNUNET_break(0);
+    GNUNET_break (0);
     GNUNET_free (h);
     return NULL;
   }
@@ -613,11 +611,11 @@ GNUNET_MESH_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls,
   size += h->n_handlers * sizeof (uint16_t);
   size += h->n_applications * sizeof (GNUNET_MESH_ApplicationType);
 
-  if (NULL != h->th) {
-      /* FIXME implement queue system instead */
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "mesh: overwriting th of mesh\n");
-      GNUNET_CLIENT_notify_transmit_ready_cancel(h->th);
+  if (NULL != h->th)
+  {
+    /* FIXME implement queue system instead */
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "mesh: overwriting th of mesh\n");
+    GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
   }
   h->th =
       GNUNET_CLIENT_notify_transmit_ready (h->client, size,
@@ -676,11 +674,11 @@ GNUNET_MESH_tunnel_create (struct GNUNET_MESH_Handle *h,
   tunnel->mesh = h;
   tunnel->tid = h->next_tid++;
   h->next_tid |= GNUNET_MESH_LOCAL_TUNNEL_ID_MARK;      // keep in range
-  if (NULL != h->th) {
-      /* FIXME implement queue system instead */
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "mesh: overwriting th of mesh\n");
-      GNUNET_CLIENT_notify_transmit_ready_cancel(h->th);
+  if (NULL != h->th)
+  {
+    /* FIXME implement queue system instead */
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "mesh: overwriting th of mesh\n");
+    GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
   }
   h->th =
       GNUNET_CLIENT_notify_transmit_ready (h->client,
@@ -703,21 +701,21 @@ GNUNET_MESH_tunnel_create (struct GNUNET_MESH_Handle *h,
 void
 GNUNET_MESH_tunnel_destroy (struct GNUNET_MESH_Tunnel *tun)
 {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: Destroying tunnel\n");
-    if (NULL != tun->mesh->th) {
-        /* FIXME implement queue system instead */
-        GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                   "mesh: overwriting th of mesh\n");
-        GNUNET_CLIENT_notify_transmit_ready_cancel(tun->mesh->th);
-    }
-    tun->mesh->th = GNUNET_CLIENT_notify_transmit_ready (
-                                         tun->mesh->client,
-                                         sizeof (struct
-                                         GNUNET_MESH_TunnelMessage),
-                                         GNUNET_TIME_UNIT_FOREVER_REL,
-                                         GNUNET_YES,
-                                         &send_tunnel_destroy_packet,
-                                         (void *) tun);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "mesh: Destroying tunnel\n");
+  if (NULL != tun->mesh->th)
+  {
+    /* FIXME implement queue system instead */
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "mesh: overwriting th of mesh\n");
+    GNUNET_CLIENT_notify_transmit_ready_cancel (tun->mesh->th);
+  }
+  tun->mesh->th =
+      GNUNET_CLIENT_notify_transmit_ready (tun->mesh->client,
+                                           sizeof (struct
+                                                   GNUNET_MESH_TunnelMessage),
+                                           GNUNET_TIME_UNIT_FOREVER_REL,
+                                           GNUNET_YES,
+                                           &send_tunnel_destroy_packet,
+                                           (void *) tun);
 }
 
 
@@ -792,7 +790,7 @@ GNUNET_MESH_peer_request_connect_by_type (struct GNUNET_MESH_Tunnel *tunnel,
  * @param priority how important is the message?
  * @param maxdelay how long can the message wait?
  * @param target destination for the message,
- *               NULL for multicast to all tunnel targets 
+ *               NULL for multicast to all tunnel targets
  * @param notify_size how many bytes of buffer space does notify want?
  * @param notify function to call when buffer space is available;
  *        will be called with NULL on timeout or if the overall queue