indentation

1 files changed, 580 insertions, 648 deletions

diff --git a/src/transport/plugin_transport_udp.c b/src/transport/plugin_transport_udp.c
index 7d8c1520f..df8447a12 100644
--- a/src/transport/plugin_transport_udp.c
+++ b/src/transport/plugin_transport_udp.c
@@ -193,7 +193,7 @@ struct ReceiveContext
 
   /**
    * Node in the defrag heap.
-   */ 
+   */
   struct GNUNET_CONTAINER_HeapNode *hnode;
 
   /**
@@ -297,11 +297,10 @@ struct Plugin
  * @return NULL if we have no session
  */
 struct PeerSession *
-find_session (struct Plugin *plugin,
-              const struct GNUNET_PeerIdentity *peer)
+find_session (struct Plugin *plugin, const struct GNUNET_PeerIdentity *peer)
 {
-  return GNUNET_CONTAINER_multihashmap_get (plugin->sessions, 
-                                            &peer->hashPubKey);
+  return GNUNET_CONTAINER_multihashmap_get (plugin->sessions,
+                                            &peer->hashPubKey);
 }
 
 
@@ -322,9 +321,9 @@ udp_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
   if (NULL == session)
     return;
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multihashmap_remove (plugin->sessions,
-                                                       &target->hashPubKey,
-                                                       session));
+                 GNUNET_CONTAINER_multihashmap_remove (plugin->sessions,
+                                                       &target->hashPubKey,
+                                                       session));
   plugin->last_expected_delay = GNUNET_FRAGMENT_context_destroy (session->frag);
   session->cont (session->cont_cls, target, GNUNET_SYSERR);
   GNUNET_free (session);
@@ -352,48 +351,43 @@ udp_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
  */
 static ssize_t
 udp_send (struct Plugin *plugin,
-          const struct sockaddr *sa,
-          const struct GNUNET_MessageHeader *msg)
+          const struct sockaddr *sa, const struct GNUNET_MessageHeader *msg)
 {
   ssize_t sent;
   size_t slen;
 
   switch (sa->sa_family)
-    {
-    case AF_INET:
-      if (NULL == plugin->sockv4)
-        return 0;
-      sent =
-        GNUNET_NETWORK_socket_sendto (plugin->sockv4,
-                                      msg,
-                                      ntohs (msg->size),
-                                      sa,
-                                      slen = sizeof (struct sockaddr_in));
-      break;
-    case AF_INET6:
-      if (NULL == plugin->sockv6)
-        return 0;
-      sent =
-        GNUNET_NETWORK_socket_sendto (plugin->sockv6,
-                                      msg,
-                                      ntohs (msg->size),
-                                      sa,
-                                      slen = sizeof (struct sockaddr_in6));
-      break;
-    default:
-      GNUNET_break (0);
+  {
+  case AF_INET:
+    if (NULL == plugin->sockv4)
       return 0;
-    }
+    sent =
+        GNUNET_NETWORK_socket_sendto (plugin->sockv4,
+                                      msg,
+                                      ntohs (msg->size),
+                                      sa, slen = sizeof (struct sockaddr_in));
+    break;
+  case AF_INET6:
+    if (NULL == plugin->sockv6)
+      return 0;
+    sent =
+        GNUNET_NETWORK_socket_sendto (plugin->sockv6,
+                                      msg,
+                                      ntohs (msg->size),
+                                      sa, slen = sizeof (struct sockaddr_in6));
+    break;
+  default:
+    GNUNET_break (0);
+    return 0;
+  }
   if (GNUNET_SYSERR == sent)
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, 
-                         "sendto");
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "sendto");
 #if DEBUG_UDP
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "UDP transmited %u-byte message to %s (%d: %s)\n",
-              (unsigned int) ntohs (msg->size),
-              GNUNET_a2s (sa, slen),
-              (int) sent,
-              (sent < 0) ? STRERROR (errno) : "ok");
+              "UDP transmited %u-byte message to %s (%d: %s)\n",
+              (unsigned int) ntohs (msg->size),
+              GNUNET_a2s (sa, slen),
+              (int) sent, (sent < 0) ? STRERROR (errno) : "ok");
 #endif
   return sent;
 }
@@ -408,15 +402,12 @@ udp_send (struct Plugin *plugin,
  * @param cls closure, the 'struct PeerSession'
  * @param msg the message that was created
  */
-static void 
-send_fragment (void *cls,
-               const struct GNUNET_MessageHeader *msg)
+static void
+send_fragment (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct PeerSession *session = cls;
 
-  udp_send (session->plugin,
-            session->sock_addr,
-            msg);
+  udp_send (session->plugin, session->sock_addr, msg);
   GNUNET_FRAGMENT_context_transmission_done (session->frag);
 }
 
@@ -447,16 +438,16 @@ send_fragment (void *cls,
  */
 static ssize_t
 udp_plugin_send (void *cls,
-                 const struct GNUNET_PeerIdentity *target,
-                 const char *msgbuf,
-                 size_t msgbuf_size,
-                 unsigned int priority,
-                 struct GNUNET_TIME_Relative timeout,
-                 struct Session *session,
-                 const void *addr,
-                 size_t addrlen,
-                 int force_address,
-                 GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
+                 const struct GNUNET_PeerIdentity *target,
+                 const char *msgbuf,
+                 size_t msgbuf_size,
+                 unsigned int priority,
+                 struct GNUNET_TIME_Relative timeout,
+                 struct Session *session,
+                 const void *addr,
+                 size_t addrlen,
+                 int force_address,
+                 GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
 {
   struct Plugin *plugin = cls;
   struct PeerSession *peer_session;
@@ -472,50 +463,54 @@ udp_plugin_send (void *cls,
     return GNUNET_SYSERR;
   GNUNET_assert (NULL == session);
   if (mlen >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   switch (addrlen)
+  {
+  case sizeof (struct IPv4UdpAddress):
+    if (NULL == plugin->sockv4)
     {
-    case sizeof(struct IPv4UdpAddress):   
-      if (NULL == plugin->sockv4)
-        {
-          cont (cont_cls, target, GNUNET_SYSERR);
-          return 0;
-        }
-      t4 = addr;
-      peer_session = GNUNET_malloc (sizeof (struct PeerSession) + sizeof (struct sockaddr_in));
-      v4 = (struct sockaddr_in*) &peer_session[1];
-      v4->sin_family = AF_INET;
+      cont (cont_cls, target, GNUNET_SYSERR);
+      return 0;
+    }
+    t4 = addr;
+    peer_session =
+        GNUNET_malloc (sizeof (struct PeerSession) +
+                       sizeof (struct sockaddr_in));
+    v4 = (struct sockaddr_in *) &peer_session[1];
+    v4->sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      v4->sin_len = sizeof (struct sockaddr_in);
+    v4->sin_len = sizeof (struct sockaddr_in);
 #endif
-      v4->sin_port = t4->u4_port;
-      v4->sin_addr.s_addr = t4->ipv4_addr;
-      break;
-    case sizeof(struct IPv6UdpAddress):
-      if (NULL == plugin->sockv6)
-        {
-          cont (cont_cls, target, GNUNET_SYSERR);
-          return 0;
-        }
-      t6 = addr;
-      peer_session = GNUNET_malloc (sizeof (struct PeerSession) + sizeof (struct sockaddr_in6));
-      v6 = (struct sockaddr_in6*) &peer_session[1];
-      v6->sin6_family = AF_INET6;
+    v4->sin_port = t4->u4_port;
+    v4->sin_addr.s_addr = t4->ipv4_addr;
+    break;
+  case sizeof (struct IPv6UdpAddress):
+    if (NULL == plugin->sockv6)
+    {
+      cont (cont_cls, target, GNUNET_SYSERR);
+      return 0;
+    }
+    t6 = addr;
+    peer_session =
+        GNUNET_malloc (sizeof (struct PeerSession) +
+                       sizeof (struct sockaddr_in6));
+    v6 = (struct sockaddr_in6 *) &peer_session[1];
+    v6->sin6_family = AF_INET6;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      v6->sin6_len = sizeof (struct sockaddr_in6);
+    v6->sin6_len = sizeof (struct sockaddr_in6);
 #endif
-      v6->sin6_port = t6->u6_port;
-      v6->sin6_addr = t6->ipv6_addr;
-      break;
-    default:
-      /* Must have a valid address to send to */
-      GNUNET_break_op(0);
-      return GNUNET_SYSERR;
-    }
-  udp = (struct UDPMessage*) mbuf;
+    v6->sin6_port = t6->u6_port;
+    v6->sin6_addr = t6->ipv6_addr;
+    break;
+  default:
+    /* Must have a valid address to send to */
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  udp = (struct UDPMessage *) mbuf;
   udp->header.size = htons (mlen);
   udp->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE);
   udp->reserved = htonl (0);
@@ -523,32 +518,30 @@ udp_plugin_send (void *cls,
   memcpy (&udp[1], msgbuf, msgbuf_size);
   peer_session->target = *target;
   peer_session->plugin = plugin;
-  peer_session->sock_addr = (const struct sockaddr*) &peer_session[1];
+  peer_session->sock_addr = (const struct sockaddr *) &peer_session[1];
   peer_session->cont = cont;
-  peer_session->cont_cls = cont_cls;  
+  peer_session->cont_cls = cont_cls;
   if (mlen <= UDP_MTU)
-    {
-      mlen = udp_send (plugin, 
-                       peer_session->sock_addr,
-                       &udp->header);
-      cont (cont_cls, target, (mlen > 0) ? GNUNET_OK : GNUNET_SYSERR);
-      GNUNET_free (peer_session);      
-    }
+  {
+    mlen = udp_send (plugin, peer_session->sock_addr, &udp->header);
+    cont (cont_cls, target, (mlen > 0) ? GNUNET_OK : GNUNET_SYSERR);
+    GNUNET_free (peer_session);
+  }
   else
-    {
-      GNUNET_assert (GNUNET_OK ==
-                     GNUNET_CONTAINER_multihashmap_put (plugin->sessions,
-                                                        &target->hashPubKey,
-                                                        peer_session,
-                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-      peer_session->frag = GNUNET_FRAGMENT_context_create (plugin->env->stats,
-                                                           UDP_MTU,
-                                                           &plugin->tracker,
-                                                           plugin->last_expected_delay,
-                                                           &udp->header,
-                                                           &send_fragment,
-                                                           peer_session);
-    }
+  {
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multihashmap_put (plugin->sessions,
+                                                      &target->hashPubKey,
+                                                      peer_session,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+    peer_session->frag = GNUNET_FRAGMENT_context_create (plugin->env->stats,
+                                                         UDP_MTU,
+                                                         &plugin->tracker,
+                                                         plugin->last_expected_delay,
+                                                         &udp->header,
+                                                         &send_fragment,
+                                                         peer_session);
+  }
   return mlen;
 }
 
@@ -562,7 +555,7 @@ struct SourceInformation
    * Sender identity.
    */
   struct GNUNET_PeerIdentity sender;
-  
+
   /**
    * Source address.
    */
@@ -585,11 +578,11 @@ struct SourceInformation
  */
 static void
 process_inbound_tokenized_messages (void *cls,
-                                    void *client,
-                                    const struct GNUNET_MessageHeader *hdr)
+                                    void *client,
+                                    const struct GNUNET_MessageHeader *hdr)
 {
   struct Plugin *plugin = cls;
-  struct SourceInformation* si = client;
+  struct SourceInformation *si = client;
   struct GNUNET_TRANSPORT_ATS_Information distance[2];
 
   /* setup ATS */
@@ -598,12 +591,8 @@ process_inbound_tokenized_messages (void *cls,
   distance[1].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
   distance[1].value = htonl (0);
 
-  plugin->env->receive (plugin->env->cls, 
-                        &si->sender, 
-                        hdr,
-                        distance, 2,
-                        NULL, 
-                        si->arg, si->args);
+  plugin->env->receive (plugin->env->cls,
+                        &si->sender, hdr, distance, 2, NULL, si->arg, si->args);
 }
 
 
@@ -617,55 +606,56 @@ process_inbound_tokenized_messages (void *cls,
  */
 static void
 process_udp_message (struct Plugin *plugin,
-                     const struct UDPMessage *msg,
-                     const struct sockaddr *sender_addr,
-                     socklen_t sender_addr_len)
+                     const struct UDPMessage *msg,
+                     const struct sockaddr *sender_addr,
+                     socklen_t sender_addr_len)
 {
   struct SourceInformation si;
   struct IPv4UdpAddress u4;
   struct IPv6UdpAddress u6;
   const void *arg;
   size_t args;
-                                          
+
   if (0 != ntohl (msg->reserved))
-    {
-      GNUNET_break_op (0);
-      return;
-    }
-  if (ntohs (msg->header.size) < sizeof (struct GNUNET_MessageHeader) + sizeof (struct UDPMessage))
-    {
-      GNUNET_break_op (0);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  if (ntohs (msg->header.size) <
+      sizeof (struct GNUNET_MessageHeader) + sizeof (struct UDPMessage))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
 
   /* convert address */
   switch (sender_addr->sa_family)
-    {
-    case AF_INET:
-      GNUNET_assert (sender_addr_len == sizeof (struct sockaddr_in));
-      u4.ipv4_addr = ((struct sockaddr_in *) sender_addr)->sin_addr.s_addr;
-      u4.u4_port = ((struct sockaddr_in *) sender_addr)->sin_port;
-      arg = &u4;
-      args = sizeof (u4);
-      break;
-    case AF_INET6:
-      GNUNET_assert (sender_addr_len == sizeof (struct sockaddr_in6));
-      u6.ipv6_addr = ((struct sockaddr_in6*) sender_addr)->sin6_addr;
-      u6.u6_port = ((struct sockaddr_in6 *) sender_addr)->sin6_port;
-      arg = &u6;
-      args = sizeof (u6);    
-      break;
-    default:
-      GNUNET_break (0);
-      return;
-    }
+  {
+  case AF_INET:
+    GNUNET_assert (sender_addr_len == sizeof (struct sockaddr_in));
+    u4.ipv4_addr = ((struct sockaddr_in *) sender_addr)->sin_addr.s_addr;
+    u4.u4_port = ((struct sockaddr_in *) sender_addr)->sin_port;
+    arg = &u4;
+    args = sizeof (u4);
+    break;
+  case AF_INET6:
+    GNUNET_assert (sender_addr_len == sizeof (struct sockaddr_in6));
+    u6.ipv6_addr = ((struct sockaddr_in6 *) sender_addr)->sin6_addr;
+    u6.u6_port = ((struct sockaddr_in6 *) sender_addr)->sin6_port;
+    arg = &u6;
+    args = sizeof (u6);
+    break;
+  default:
+    GNUNET_break (0);
+    return;
+  }
 #if DEBUG_UDP
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "udp",
-                   "Received message with %u bytes from peer `%s' at `%s'\n",
-                   (unsigned int) ntohs (msg->header.size),
-                   GNUNET_i2s (&msg->sender),
-                   GNUNET_a2s (sender_addr, sender_addr_len));
+                   "udp",
+                   "Received message with %u bytes from peer `%s' at `%s'\n",
+                   (unsigned int) ntohs (msg->header.size),
+                   GNUNET_i2s (&msg->sender),
+                   GNUNET_a2s (sender_addr, sender_addr_len));
 #endif
 
   /* iterate over all embedded messages */
@@ -673,11 +663,10 @@ process_udp_message (struct Plugin *plugin,
   si.arg = arg;
   si.args = args;
   GNUNET_SERVER_mst_receive (plugin->mst,
-                             &si,
-                             (const char*) &msg[1],
-                             ntohs (msg->header.size) - sizeof (struct UDPMessage),
-                             GNUNET_YES,
-                             GNUNET_NO);
+                             &si,
+                             (const char *) &msg[1],
+                             ntohs (msg->header.size) -
+                             sizeof (struct UDPMessage), GNUNET_YES, GNUNET_NO);
 }
 
 
@@ -688,26 +677,24 @@ process_udp_message (struct Plugin *plugin,
  * @param msg the message
  */
 static void
-fragment_msg_proc (void *cls,
-                   const struct GNUNET_MessageHeader *msg)
+fragment_msg_proc (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct ReceiveContext *rc = cls;
 
   if (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE)
-    {
-      GNUNET_break (0);
-      return;
-    }
-  if (ntohs (msg->size) < sizeof(struct UDPMessage))
-    {
-      GNUNET_break (0);
-      return;
-    }   
+  {
+    GNUNET_break (0);
+    return;
+  }
+  if (ntohs (msg->size) < sizeof (struct UDPMessage))
+  {
+    GNUNET_break (0);
+    return;
+  }
   process_udp_message (rc->plugin,
-                       (const struct UDPMessage*) msg,
-                       rc->src_addr,
-                       rc->addr_len);
-}                  
+                       (const struct UDPMessage *) msg,
+                       rc->src_addr, rc->addr_len);
+}
 
 
 /**
@@ -718,9 +705,7 @@ fragment_msg_proc (void *cls,
  * @param msg ack to transmit
  */
 static void
-ack_proc (void *cls,
-          uint32_t id,
-          const struct GNUNET_MessageHeader *msg)
+ack_proc (void *cls, uint32_t id, const struct GNUNET_MessageHeader *msg)
 {
   struct ReceiveContext *rc = cls;
   size_t msize = sizeof (struct UDPMessage) + ntohs (msg->size);
@@ -729,22 +714,20 @@ ack_proc (void *cls,
 
 #if DEBUG_UDP
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "udp",
-                   "Sending ACK to `%s'\n",
-                   GNUNET_a2s (rc->src_addr, 
-                               (rc->src_addr->sa_family == AF_INET)
-                               ? sizeof (struct sockaddr_in) 
-                               : sizeof (struct sockaddr_in6)));
+                   "udp",
+                   "Sending ACK to `%s'\n",
+                   GNUNET_a2s (rc->src_addr,
+                               (rc->src_addr->sa_family == AF_INET)
+                               ? sizeof (struct sockaddr_in)
+                               : sizeof (struct sockaddr_in6)));
 #endif
-  udp = (struct UDPMessage*) buf;
+  udp = (struct UDPMessage *) buf;
   udp->header.size = htons ((uint16_t) msize);
   udp->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK);
   udp->reserved = htonl (0);
   udp->sender = *rc->plugin->env->my_identity;
   memcpy (&udp[1], msg, ntohs (msg->size));
-  (void) udp_send (rc->plugin, 
-                   rc->src_addr,
-                   &udp->header);
+  (void) udp_send (rc->plugin, rc->src_addr, &udp->header);
 }
 
 
@@ -782,21 +765,18 @@ struct FindReceiveContext
  */
 static int
 find_receive_context (void *cls,
-                      struct GNUNET_CONTAINER_HeapNode *node,
-                      void *element,
-                      GNUNET_CONTAINER_HeapCostType cost)
+                      struct GNUNET_CONTAINER_HeapNode *node,
+                      void *element, GNUNET_CONTAINER_HeapCostType cost)
 {
   struct FindReceiveContext *frc = cls;
   struct ReceiveContext *e = element;
 
-  if ( (frc->addr_len == e->addr_len) &&
-       (0 == memcmp (frc->addr,
-                     e->src_addr,
-                     frc->addr_len) ) )
-    {
-      frc->rc = e;
-      return GNUNET_NO;
-    }
+  if ((frc->addr_len == e->addr_len) &&
+      (0 == memcmp (frc->addr, e->src_addr, frc->addr_len)))
+  {
+    frc->rc = e;
+    return GNUNET_NO;
+  }
   return GNUNET_YES;
 }
 
@@ -808,8 +788,7 @@ find_receive_context (void *cls,
  * @param rsock socket to read from
  */
 static void
-udp_read (struct Plugin *plugin,
-          struct GNUNET_NETWORK_Handle *rsock)
+udp_read (struct Plugin *plugin, struct GNUNET_NETWORK_Handle *rsock)
 {
   socklen_t fromlen;
   char addr[32];
@@ -824,144 +803,142 @@ udp_read (struct Plugin *plugin,
   struct FindReceiveContext frc;
 
   fromlen = sizeof (addr);
-  memset (&addr, 0, sizeof(addr));
+  memset (&addr, 0, sizeof (addr));
   ret = GNUNET_NETWORK_socket_recvfrom (rsock, buf, sizeof (buf),
-                                        (struct sockaddr *)&addr, &fromlen);
+                                        (struct sockaddr *) &addr, &fromlen);
   if (ret < sizeof (struct GNUNET_MessageHeader))
-    {
-      GNUNET_break_op (0);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    return;
+  }
 #if DEBUG_UDP
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "UDP received %u-byte message from `%s'\n",
-              (unsigned int) ret,
-              GNUNET_a2s ((const struct sockaddr*) addr, fromlen));
+              "UDP received %u-byte message from `%s'\n",
+              (unsigned int) ret,
+              GNUNET_a2s ((const struct sockaddr *) addr, fromlen));
 #endif
   msg = (const struct GNUNET_MessageHeader *) buf;
   if (ret != ntohs (msg->size))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  switch (ntohs (msg->type))
+  {
+  case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE:
+    if (ntohs (msg->size) < sizeof (struct UDPMessage))
     {
       GNUNET_break_op (0);
       return;
     }
-  switch (ntohs (msg->type))
+    process_udp_message (plugin,
+                         (const struct UDPMessage *) msg,
+                         (const struct sockaddr *) addr, fromlen);
+    return;
+  case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK:
+    if (ntohs (msg->size) <
+        sizeof (struct UDPMessage) + sizeof (struct GNUNET_MessageHeader))
     {
-    case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_MESSAGE:
-      if (ntohs (msg->size) < sizeof (struct UDPMessage))
-        {
-          GNUNET_break_op (0);
-          return;
-        }
-      process_udp_message (plugin,
-                           (const struct UDPMessage *) msg,
-                           (const struct sockaddr*) addr,
-                           fromlen);
+      GNUNET_break_op (0);
       return;
-    case GNUNET_MESSAGE_TYPE_TRANSPORT_UDP_ACK:
-      if (ntohs (msg->size) < sizeof (struct UDPMessage) + sizeof (struct GNUNET_MessageHeader))
-        {
-          GNUNET_break_op (0);
-          return;
-        }
-      udp = (const struct UDPMessage *) msg;
-      if (ntohl (udp->reserved) != 0)
-        {
-          GNUNET_break_op (0);
-          return;
-        }
-      ack = (const struct GNUNET_MessageHeader*) &udp[1];      
-      if (ntohs (ack->size) != ntohs (msg->size) - sizeof (struct UDPMessage))
-        {
-          GNUNET_break_op (0);
-          return;
-        }
+    }
+    udp = (const struct UDPMessage *) msg;
+    if (ntohl (udp->reserved) != 0)
+    {
+      GNUNET_break_op (0);
+      return;
+    }
+    ack = (const struct GNUNET_MessageHeader *) &udp[1];
+    if (ntohs (ack->size) != ntohs (msg->size) - sizeof (struct UDPMessage))
+    {
+      GNUNET_break_op (0);
+      return;
+    }
 #if DEBUG_UDP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "UDP processes %u-byte acknowledgement from `%s' at `%s'\n",
-                  (unsigned int) ntohs (msg->size),
-                  GNUNET_i2s (&udp->sender),
-                  GNUNET_a2s ((const struct sockaddr*) addr, fromlen));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "UDP processes %u-byte acknowledgement from `%s' at `%s'\n",
+                (unsigned int) ntohs (msg->size),
+                GNUNET_i2s (&udp->sender),
+                GNUNET_a2s ((const struct sockaddr *) addr, fromlen));
 #endif
 
-      peer_session = find_session (plugin, &udp->sender);
-      if (NULL == peer_session)
-        {
+    peer_session = find_session (plugin, &udp->sender);
+    if (NULL == peer_session)
+    {
 #if DEBUG_UDP
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Session for ACK not found, dropping ACK!\n");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Session for ACK not found, dropping ACK!\n");
 #endif
-          return; 
-        }
-      if (GNUNET_OK !=
-          GNUNET_FRAGMENT_process_ack (peer_session->frag,
-                                       ack))
-        return; 
-      GNUNET_assert (GNUNET_OK ==
-                     GNUNET_CONTAINER_multihashmap_remove (plugin->sessions,
-                                                           &udp->sender.hashPubKey,
-                                                           peer_session));
-      plugin->last_expected_delay = GNUNET_FRAGMENT_context_destroy (peer_session->frag);
-      peer_session->cont (peer_session->cont_cls,
-                          &udp->sender, 
-                          GNUNET_OK);
-      GNUNET_free (peer_session);
       return;
-    case GNUNET_MESSAGE_TYPE_FRAGMENT:
-      frc.rc = NULL;
-      frc.addr = (const struct sockaddr*) addr;
-      frc.addr_len = fromlen;
-      GNUNET_CONTAINER_heap_iterate (plugin->defrags,
-                                     &find_receive_context,
-                                     &frc);
-      now = GNUNET_TIME_absolute_get ();
-      rc = frc.rc;
-      if (rc == NULL)
-        {
-          /* need to create a new RC */
-          rc = GNUNET_malloc (sizeof (struct ReceiveContext) + fromlen);
-          memcpy (&rc[1], addr, fromlen);
-          rc->src_addr = (const struct sockaddr*) &rc[1];
-          rc->addr_len = fromlen;
-          rc->plugin = plugin;
-          rc->defrag = GNUNET_DEFRAGMENT_context_create (plugin->env->stats,
-                                                         UDP_MTU,
-                                                         UDP_MAX_MESSAGES_IN_DEFRAG,
-                                                         rc,
-                                                         &fragment_msg_proc,
-                                                         &ack_proc);
-          rc->hnode = GNUNET_CONTAINER_heap_insert (plugin->defrags,
-                                                    rc,
-                                                    (GNUNET_CONTAINER_HeapCostType) now.abs_value);
-        }
+    }
+    if (GNUNET_OK != GNUNET_FRAGMENT_process_ack (peer_session->frag, ack))
+      return;
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multihashmap_remove (plugin->sessions,
+                                                         &udp->
+                                                         sender.hashPubKey,
+                                                         peer_session));
+    plugin->last_expected_delay =
+        GNUNET_FRAGMENT_context_destroy (peer_session->frag);
+    peer_session->cont (peer_session->cont_cls, &udp->sender, GNUNET_OK);
+    GNUNET_free (peer_session);
+    return;
+  case GNUNET_MESSAGE_TYPE_FRAGMENT:
+    frc.rc = NULL;
+    frc.addr = (const struct sockaddr *) addr;
+    frc.addr_len = fromlen;
+    GNUNET_CONTAINER_heap_iterate (plugin->defrags,
+                                   &find_receive_context, &frc);
+    now = GNUNET_TIME_absolute_get ();
+    rc = frc.rc;
+    if (rc == NULL)
+    {
+      /* need to create a new RC */
+      rc = GNUNET_malloc (sizeof (struct ReceiveContext) + fromlen);
+      memcpy (&rc[1], addr, fromlen);
+      rc->src_addr = (const struct sockaddr *) &rc[1];
+      rc->addr_len = fromlen;
+      rc->plugin = plugin;
+      rc->defrag = GNUNET_DEFRAGMENT_context_create (plugin->env->stats,
+                                                     UDP_MTU,
+                                                     UDP_MAX_MESSAGES_IN_DEFRAG,
+                                                     rc,
+                                                     &fragment_msg_proc,
+                                                     &ack_proc);
+      rc->hnode = GNUNET_CONTAINER_heap_insert (plugin->defrags,
+                                                rc,
+                                                (GNUNET_CONTAINER_HeapCostType)
+                                                now.abs_value);
+    }
 #if DEBUG_UDP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "UDP processes %u-byte fragment from `%s'\n",
-                  (unsigned int) ntohs (msg->size),
-                  GNUNET_a2s ((const struct sockaddr*) addr, fromlen));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "UDP processes %u-byte fragment from `%s'\n",
+                (unsigned int) ntohs (msg->size),
+                GNUNET_a2s ((const struct sockaddr *) addr, fromlen));
 #endif
 
-      if (GNUNET_OK == 
-          GNUNET_DEFRAGMENT_process_fragment (rc->defrag,
-                                              msg))
-        {
-          /* keep this 'rc' from expiring */
-          GNUNET_CONTAINER_heap_update_cost (plugin->defrags,
-                                             rc->hnode,
-                                             (GNUNET_CONTAINER_HeapCostType) now.abs_value);
-        }
-      if (GNUNET_CONTAINER_heap_get_size (plugin->defrags) > UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG)
-        {
-          /* remove 'rc' that was inactive the longest */
-          rc = GNUNET_CONTAINER_heap_remove_root (plugin->defrags);
-          GNUNET_assert (NULL != rc);
-          GNUNET_DEFRAGMENT_context_destroy (rc->defrag);
-          GNUNET_free (rc);
-        }      
-      return;
-    default:
-      GNUNET_break_op (0);
-      return;
+    if (GNUNET_OK == GNUNET_DEFRAGMENT_process_fragment (rc->defrag, msg))
+    {
+      /* keep this 'rc' from expiring */
+      GNUNET_CONTAINER_heap_update_cost (plugin->defrags,
+                                         rc->hnode,
+                                         (GNUNET_CONTAINER_HeapCostType)
+                                         now.abs_value);
     }
+    if (GNUNET_CONTAINER_heap_get_size (plugin->defrags) >
+        UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG)
+    {
+      /* remove 'rc' that was inactive the longest */
+      rc = GNUNET_CONTAINER_heap_remove_root (plugin->defrags);
+      GNUNET_assert (NULL != rc);
+      GNUNET_DEFRAGMENT_context_destroy (rc->defrag);
+      GNUNET_free (rc);
+    }
+    return;
+  default:
+    GNUNET_break_op (0);
+    return;
+  }
 }
 
 
@@ -974,28 +951,25 @@ udp_read (struct Plugin *plugin,
  * @param tc the scheduling context (for rescheduling this function again)
  */
 static void
-udp_plugin_select (void *cls,
-                   const struct GNUNET_SCHEDULER_TaskContext *tc)
+udp_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct Plugin *plugin = cls;
 
   plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
     return;
-  if ( (NULL != plugin->sockv4) &&
-       (GNUNET_NETWORK_fdset_isset (tc->read_ready,
-                                    plugin->sockv4)) )
+  if ((NULL != plugin->sockv4) &&
+      (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->sockv4)))
     udp_read (plugin, plugin->sockv4);
-  if ( (NULL != plugin->sockv6) &&
-       (GNUNET_NETWORK_fdset_isset (tc->read_ready,
-                                    plugin->sockv6)) )
+  if ((NULL != plugin->sockv6) &&
+      (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->sockv6)))
     udp_read (plugin, plugin->sockv6);
   plugin->select_task =
-    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                 GNUNET_SCHEDULER_NO_TASK,
-                                 GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
-                                 NULL, &udp_plugin_select, plugin);
-  
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                   GNUNET_SCHEDULER_NO_TASK,
+                                   GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
+                                   NULL, &udp_plugin_select, plugin);
+
 }
 
 
@@ -1011,8 +985,7 @@ udp_plugin_select (void *cls,
 static int
 check_port (struct Plugin *plugin, uint16_t in_port)
 {
-  if ( (in_port == plugin->port) ||
-       (in_port == plugin->aport) )
+  if ((in_port == plugin->port) || (in_port == plugin->aport))
     return GNUNET_OK;
   return GNUNET_SYSERR;
 }
@@ -1035,9 +1008,7 @@ check_port (struct Plugin *plugin, uint16_t in_port)
  *
  */
 static int
-udp_plugin_check_address (void *cls,
-                          const void *addr,
-                          size_t addrlen)
+udp_plugin_check_address (void *cls, const void *addr, size_t addrlen)
 {
   struct Plugin *plugin = cls;
   struct IPv4UdpAddress *v4;
@@ -1045,37 +1016,35 @@ udp_plugin_check_address (void *cls,
 
   if ((addrlen != sizeof (struct IPv4UdpAddress)) &&
       (addrlen != sizeof (struct IPv6UdpAddress)))
-    {
-      GNUNET_break_op (0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
   if (addrlen == sizeof (struct IPv4UdpAddress))
-    {
-      v4 = (struct IPv4UdpAddress *) addr;
-      if (GNUNET_OK !=
-          check_port (plugin, ntohs (v4->u4_port)))
-        return GNUNET_SYSERR;
-      if (GNUNET_OK !=
-          GNUNET_NAT_test_address (plugin->nat, 
-                                   &v4->ipv4_addr, sizeof (struct in_addr)))
-        return GNUNET_SYSERR;
-    }
+  {
+    v4 = (struct IPv4UdpAddress *) addr;
+    if (GNUNET_OK != check_port (plugin, ntohs (v4->u4_port)))
+      return GNUNET_SYSERR;
+    if (GNUNET_OK !=
+        GNUNET_NAT_test_address (plugin->nat,
+                                 &v4->ipv4_addr, sizeof (struct in_addr)))
+      return GNUNET_SYSERR;
+  }
   else
+  {
+    v6 = (struct IPv6UdpAddress *) addr;
+    if (IN6_IS_ADDR_LINKLOCAL (&v6->ipv6_addr))
     {
-      v6 = (struct IPv6UdpAddress *) addr;
-      if (IN6_IS_ADDR_LINKLOCAL (&v6->ipv6_addr))
-        {
-          GNUNET_break_op (0);
-          return GNUNET_SYSERR;
-        }
-      if (GNUNET_OK !=
-          check_port (plugin, ntohs (v6->u6_port)))
-        return GNUNET_SYSERR;
-      if (GNUNET_OK !=
-          GNUNET_NAT_test_address (plugin->nat,
-                                   &v6->ipv6_addr, sizeof (struct in6_addr)))
-        return GNUNET_SYSERR;
+      GNUNET_break_op (0);
+      return GNUNET_SYSERR;
     }
+    if (GNUNET_OK != check_port (plugin, ntohs (v6->u6_port)))
+      return GNUNET_SYSERR;
+    if (GNUNET_OK !=
+        GNUNET_NAT_test_address (plugin->nat,
+                                 &v6->ipv6_addr, sizeof (struct in6_addr)))
+      return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -1091,10 +1060,8 @@ udp_plugin_check_address (void *cls,
  * @param addrlen length of the address
  * @return string representing the same address
  */
-static const char*
-udp_address_to_string (void *cls,
-                       const void *addr,
-                       size_t addrlen)
+static const char *
+udp_address_to_string (void *cls, const void *addr, size_t addrlen)
 {
   static char rbuf[INET6_ADDRSTRLEN + 10];
   char buf[INET6_ADDRSTRLEN];
@@ -1107,32 +1074,28 @@ udp_address_to_string (void *cls,
   uint16_t port;
 
   if (addrlen == sizeof (struct IPv6UdpAddress))
-    {
-      t6 = addr;
-      af = AF_INET6;
-      port = ntohs (t6->u6_port);
-      memcpy (&a6, &t6->ipv6_addr, sizeof (a6));
-      sb = &a6;
-    }
+  {
+    t6 = addr;
+    af = AF_INET6;
+    port = ntohs (t6->u6_port);
+    memcpy (&a6, &t6->ipv6_addr, sizeof (a6));
+    sb = &a6;
+  }
   else if (addrlen == sizeof (struct IPv4UdpAddress))
-    {
-      t4 = addr;
-      af = AF_INET;
-      port = ntohs (t4->u4_port);
-      memcpy (&a4, &t4->ipv4_addr, sizeof (a4));
-      sb = &a4;
-    }
+  {
+    t4 = addr;
+    af = AF_INET;
+    port = ntohs (t4->u4_port);
+    memcpy (&a4, &t4->ipv4_addr, sizeof (a4));
+    sb = &a4;
+  }
   else
-    {
-      GNUNET_break_op (0);
-      return NULL;
-    }
+  {
+    GNUNET_break_op (0);
+    return NULL;
+  }
   inet_ntop (af, sb, buf, INET6_ADDRSTRLEN);
-  GNUNET_snprintf (rbuf,
-                   sizeof (rbuf),
-                   "%s:%u",
-                   buf,
-                   port);
+  GNUNET_snprintf (rbuf, sizeof (rbuf), "%s:%u", buf, port);
   return rbuf;
 }
 
@@ -1172,15 +1135,12 @@ append_port (void *cls, const char *hostname)
   char *ret;
 
   if (hostname == NULL)
-    {
-      ppc->asc (ppc->asc_cls, NULL);
-      GNUNET_free (ppc);
-      return;
-    }
-  GNUNET_asprintf (&ret,
-                   "%s:%d",
-                   hostname, 
-                   ppc->port);
+  {
+    ppc->asc (ppc->asc_cls, NULL);
+    GNUNET_free (ppc);
+    return;
+  }
+  GNUNET_asprintf (&ret, "%s:%d", hostname, ppc->port);
   ppc->asc (ppc->asc_cls, ret);
   GNUNET_free (ret);
 }
@@ -1220,50 +1180,45 @@ udp_plugin_address_pretty_printer (void *cls,
   uint16_t port;
 
   if (addrlen == sizeof (struct IPv6UdpAddress))
-    {
-      u6 = addr;
-      memset (&a6, 0, sizeof (a6));
-      a6.sin6_family = AF_INET6;
+  {
+    u6 = addr;
+    memset (&a6, 0, sizeof (a6));
+    a6.sin6_family = AF_INET6;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      a6.sin6_len = sizeof (a6);
+    a6.sin6_len = sizeof (a6);
 #endif
-      a6.sin6_port = u6->u6_port;
-      memcpy (&a6.sin6_addr,
-              &u6->ipv6_addr,
-              sizeof (struct in6_addr));
-      port = ntohs (u6->u6_port);
-      sb = &a6;
-      sbs = sizeof (a6);
-    }
+    a6.sin6_port = u6->u6_port;
+    memcpy (&a6.sin6_addr, &u6->ipv6_addr, sizeof (struct in6_addr));
+    port = ntohs (u6->u6_port);
+    sb = &a6;
+    sbs = sizeof (a6);
+  }
   else if (addrlen == sizeof (struct IPv4UdpAddress))
-    {
-      u4 = addr;
-      memset (&a4, 0, sizeof (a4));
-      a4.sin_family = AF_INET;
+  {
+    u4 = addr;
+    memset (&a4, 0, sizeof (a4));
+    a4.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      a4.sin_len = sizeof (a4);
+    a4.sin_len = sizeof (a4);
 #endif
-      a4.sin_port = u4->u4_port;
-      a4.sin_addr.s_addr = u4->ipv4_addr;
-      port = ntohs (u4->u4_port);
-      sb = &a4;
-      sbs = sizeof (a4);
-    }
+    a4.sin_port = u4->u4_port;
+    a4.sin_addr.s_addr = u4->ipv4_addr;
+    port = ntohs (u4->u4_port);
+    sb = &a4;
+    sbs = sizeof (a4);
+  }
   else
-    {
-      /* invalid address */
-      GNUNET_break_op (0);
-      asc (asc_cls, NULL);
-      return;
-    }
+  {
+    /* invalid address */
+    GNUNET_break_op (0);
+    asc (asc_cls, NULL);
+    return;
+  }
   ppc = GNUNET_malloc (sizeof (struct PrettyPrinterContext));
   ppc->asc = asc;
   ppc->asc_cls = asc_cls;
   ppc->port = port;
-  GNUNET_RESOLVER_hostname_get (sb,
-                                sbs,
-                                !numeric, timeout,
-                                &append_port, ppc);
+  GNUNET_RESOLVER_hostname_get (sb, sbs, !numeric, timeout, &append_port, ppc);
 }
 
 
@@ -1278,9 +1233,8 @@ udp_plugin_address_pretty_printer (void *cls,
  */
 static void
 udp_nat_port_map_callback (void *cls,
-                           int add_remove,
-                           const struct sockaddr *addr,
-                           socklen_t addrlen)
+                           int add_remove,
+                           const struct sockaddr *addr, socklen_t addrlen)
 {
   struct Plugin *plugin = cls;
   struct IPv4UdpAddress u4;
@@ -1290,31 +1244,29 @@ udp_nat_port_map_callback (void *cls,
 
   /* convert 'addr' to our internal format */
   switch (addr->sa_family)
-    {
-    case AF_INET:
-      GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
-      u4.ipv4_addr = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
-      u4.u4_port = ((struct sockaddr_in *) addr)->sin_port;
-      arg = &u4;
-      args = sizeof (u4);
-      break;
-    case AF_INET6:
-      GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
-      memcpy (&u6.ipv6_addr,
-              &((struct sockaddr_in6 *) addr)->sin6_addr,
-              sizeof (struct in6_addr));
-      u6.u6_port = ((struct sockaddr_in6 *) addr)->sin6_port;
-      arg = &u6;
-      args = sizeof (u6);    
-      break;
-    default:
-      GNUNET_break (0);
-      return;
-    }
+  {
+  case AF_INET:
+    GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
+    u4.ipv4_addr = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
+    u4.u4_port = ((struct sockaddr_in *) addr)->sin_port;
+    arg = &u4;
+    args = sizeof (u4);
+    break;
+  case AF_INET6:
+    GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
+    memcpy (&u6.ipv6_addr,
+            &((struct sockaddr_in6 *) addr)->sin6_addr,
+            sizeof (struct in6_addr));
+    u6.u6_port = ((struct sockaddr_in6 *) addr)->sin6_port;
+    arg = &u6;
+    args = sizeof (u6);
+    break;
+  default:
+    GNUNET_break (0);
+    return;
+  }
   /* modify our published address list */
-  plugin->env->notify_address (plugin->env->cls,
-                               add_remove,
-                               arg, args);
+  plugin->env->notify_address (plugin->env->cls, add_remove, arg, args);
 }
 
 
@@ -1345,38 +1297,32 @@ libgnunet_plugin_transport_udp_init (void *cls)
 
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (env->cfg,
-                                             "transport-udp",
-                                             "PORT",
-                                             &port))
+                                             "transport-udp", "PORT", &port))
     port = 2086;
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (env->cfg,
-                                             "transport-udp",
-                                             "MAX_BPS",
-                                             &udp_max_bps))
-    udp_max_bps = 1024 * 1024 * 50; /* 50 MB/s == infinity for practical purposes */
+                                             "transport-udp",
+                                             "MAX_BPS", &udp_max_bps))
+    udp_max_bps = 1024 * 1024 * 50;     /* 50 MB/s == infinity for practical purposes */
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (env->cfg,
-                                             "transport-udp",
-                                             "ADVERTISED_PORT",
-                                             &aport))
+                                             "transport-udp",
+                                             "ADVERTISED_PORT", &aport))
     aport = port;
   if (port > 65535)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Given `%s' option is out of range: %llu > %u\n"),
-                  "PORT",
-                  port,
-                  65535);
-      return NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("Given `%s' option is out of range: %llu > %u\n"),
+                "PORT", port, 65535);
+    return NULL;
+  }
   memset (&serverAddrv6, 0, sizeof (serverAddrv6));
   memset (&serverAddrv4, 0, sizeof (serverAddrv4));
 
   plugin = GNUNET_malloc (sizeof (struct Plugin));
   GNUNET_BANDWIDTH_tracker_init (&plugin->tracker,
-                                 GNUNET_BANDWIDTH_value_init ((uint32_t) udp_max_bps),
-                                 30);
+                                 GNUNET_BANDWIDTH_value_init ((uint32_t)
+                                                              udp_max_bps), 30);
   plugin->last_expected_delay = GNUNET_TIME_UNIT_SECONDS;
   plugin->port = port;
   plugin->aport = aport;
@@ -1390,178 +1336,167 @@ libgnunet_plugin_transport_udp_init (void *cls)
   api->address_to_string = &udp_address_to_string;
   api->check_address = &udp_plugin_check_address;
 
-  if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_string(env->cfg, 
-                                                          "transport-udp", 
-                                                          "BINDTO", 
-                                                          &plugin->bind4_address))
+  if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_string (env->cfg,
+                                                           "transport-udp",
+                                                           "BINDTO",
+                                                           &plugin->bind4_address))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Binding udp plugin to specific address: `%s'\n",
+                plugin->bind4_address);
+    if (1 != inet_pton (AF_INET, plugin->bind4_address, &serverAddrv4.sin_addr))
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 
-                 "Binding udp plugin to specific address: `%s'\n", 
-                 plugin->bind4_address);
-      if (1 != inet_pton(AF_INET,
-                         plugin->bind4_address, 
-                         &serverAddrv4.sin_addr))
-        {
-          GNUNET_free (plugin->bind4_address);
-          GNUNET_free (plugin);
-          GNUNET_free (api);
-          return NULL;
-        }
+      GNUNET_free (plugin->bind4_address);
+      GNUNET_free (plugin);
+      GNUNET_free (api);
+      return NULL;
     }
-
-  if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_string(env->cfg, 
-                                                          "transport-udp",
-                                                          "BINDTO6", 
-                                                          &plugin->bind6_address))
+  }
+
+  if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_string (env->cfg,
+                                                           "transport-udp",
+                                                           "BINDTO6",
+                                                           &plugin->bind6_address))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Binding udp plugin to specific address: `%s'\n",
+                plugin->bind6_address);
+    if (1 != inet_pton (AF_INET6,
+                        plugin->bind6_address, &serverAddrv6.sin6_addr))
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Binding udp plugin to specific address: `%s'\n",
-                 plugin->bind6_address);
-      if (1 != inet_pton(AF_INET6, 
-                         plugin->bind6_address, 
-                         &serverAddrv6.sin6_addr))
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                     _("Invalid IPv6 address: `%s'\n"),
-                     plugin->bind6_address);
-          GNUNET_free_non_null (plugin->bind4_address);
-          GNUNET_free (plugin->bind6_address);
-          GNUNET_free (plugin);
-          GNUNET_free (api);
-          return NULL;
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("Invalid IPv6 address: `%s'\n"), plugin->bind6_address);
+      GNUNET_free_non_null (plugin->bind4_address);
+      GNUNET_free (plugin->bind6_address);
+      GNUNET_free (plugin);
+      GNUNET_free (api);
+      return NULL;
     }
+  }
 
-  plugin->defrags = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
-  plugin->sessions = GNUNET_CONTAINER_multihashmap_create (UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG * 2);
+  plugin->defrags =
+      GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+  plugin->sessions =
+      GNUNET_CONTAINER_multihashmap_create (UDP_MAX_SENDER_ADDRESSES_WITH_DEFRAG
+                                            * 2);
   sockets_created = 0;
-  if ( (GNUNET_YES !=
-        GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
-                                              "nat",
-                                              "DISABLEV6")))
+  if ((GNUNET_YES !=
+       GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
+                                             "nat", "DISABLEV6")))
+  {
+    plugin->sockv6 = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_DGRAM, 0);
+    if (NULL == plugin->sockv6)
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "socket");
+    }
+    else
     {
-      plugin->sockv6 = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_DGRAM, 0);
-      if (NULL == plugin->sockv6)
-        {
-          GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "socket");
-        }
-      else
-        {
 #if HAVE_SOCKADDR_IN_SIN_LEN
-          serverAddrv6.sin6_len = sizeof (serverAddrv6);
+      serverAddrv6.sin6_len = sizeof (serverAddrv6);
 #endif
-          serverAddrv6.sin6_family = AF_INET6;
-          serverAddrv6.sin6_addr = in6addr_any;
-          serverAddrv6.sin6_port = htons (plugin->port);
-          addrlen = sizeof (serverAddrv6);
-          serverAddr = (struct sockaddr *) &serverAddrv6;
+      serverAddrv6.sin6_family = AF_INET6;
+      serverAddrv6.sin6_addr = in6addr_any;
+      serverAddrv6.sin6_port = htons (plugin->port);
+      addrlen = sizeof (serverAddrv6);
+      serverAddr = (struct sockaddr *) &serverAddrv6;
 #if DEBUG_UDP
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                           "Binding to IPv6 port %d\n",
-                           ntohs(serverAddrv6.sin6_port));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Binding to IPv6 port %d\n", ntohs (serverAddrv6.sin6_port));
 #endif
-          tries = 0;
-          while (GNUNET_NETWORK_socket_bind (plugin->sockv6, 
-                                             serverAddr, addrlen) !=
-                 GNUNET_OK)
-            {
-              serverAddrv6.sin6_port
-                = htons (GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000); /* Find a good, non-root port */
+      tries = 0;
+      while (GNUNET_NETWORK_socket_bind (plugin->sockv6,
+                                         serverAddr, addrlen) != GNUNET_OK)
+      {
+        serverAddrv6.sin6_port = htons (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000);        /* Find a good, non-root port */
 #if DEBUG_UDP
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                               "IPv6 Binding failed, trying new port %d\n",
-                               ntohs(serverAddrv6.sin6_port));
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "IPv6 Binding failed, trying new port %d\n",
+                    ntohs (serverAddrv6.sin6_port));
 #endif
-              tries++;
-              if (tries > 10)
-                {
-                  GNUNET_NETWORK_socket_close (plugin->sockv6);
-                  plugin->sockv6 = NULL;
-                  break;
-                }       
-            }
-          if (plugin->sockv6 != NULL)
-            {
-              addrs[sockets_created] = (struct sockaddr*)  &serverAddrv6;
-              addrlens[sockets_created] = sizeof (serverAddrv6);
-              sockets_created++;
-            }
-        }
+        tries++;
+        if (tries > 10)
+        {
+          GNUNET_NETWORK_socket_close (plugin->sockv6);
+          plugin->sockv6 = NULL;
+          break;
+        }
+      }
+      if (plugin->sockv6 != NULL)
+      {
+        addrs[sockets_created] = (struct sockaddr *) &serverAddrv6;
+        addrlens[sockets_created] = sizeof (serverAddrv6);
+        sockets_created++;
+      }
     }
+  }
 
   plugin->mst = GNUNET_SERVER_mst_create (&process_inbound_tokenized_messages,
-                                          plugin);
+                                          plugin);
   plugin->sockv4 = GNUNET_NETWORK_socket_create (PF_INET, SOCK_DGRAM, 0);
   if (NULL == plugin->sockv4)
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "socket");
-    }
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "socket");
+  }
   else
-    {
+  {
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      serverAddrv4.sin_len = sizeof (serverAddrv4);
+    serverAddrv4.sin_len = sizeof (serverAddrv4);
 #endif
-      serverAddrv4.sin_family = AF_INET;
-      serverAddrv4.sin_addr.s_addr = INADDR_ANY;
-      serverAddrv4.sin_port = htons (plugin->port);
-      addrlen = sizeof (serverAddrv4);
-      serverAddr = (struct sockaddr *) &serverAddrv4;
+    serverAddrv4.sin_family = AF_INET;
+    serverAddrv4.sin_addr.s_addr = INADDR_ANY;
+    serverAddrv4.sin_port = htons (plugin->port);
+    addrlen = sizeof (serverAddrv4);
+    serverAddr = (struct sockaddr *) &serverAddrv4;
 #if DEBUG_UDP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                       "Binding to IPv4 port %d\n",
-                       ntohs(serverAddrv4.sin_port));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Binding to IPv4 port %d\n", ntohs (serverAddrv4.sin_port));
 #endif
-      tries = 0;
-      while (GNUNET_NETWORK_socket_bind (plugin->sockv4, serverAddr, addrlen) !=
-             GNUNET_OK)
-        {
-          serverAddrv4.sin_port = htons (GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000); /* Find a good, non-root port */
+    tries = 0;
+    while (GNUNET_NETWORK_socket_bind (plugin->sockv4, serverAddr, addrlen) !=
+           GNUNET_OK)
+    {
+      serverAddrv4.sin_port = htons (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_STRONG, 33537) + 32000);   /* Find a good, non-root port */
 #if DEBUG_UDP
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                           "IPv4 Binding failed, trying new port %d\n",
-                           ntohs(serverAddrv4.sin_port));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "IPv4 Binding failed, trying new port %d\n",
+                  ntohs (serverAddrv4.sin_port));
 #endif
-          tries++;
-          if (tries > 10)
-            {
-              GNUNET_NETWORK_socket_close (plugin->sockv4);
-              plugin->sockv4 = NULL;
-              break;
-            }   
-        }
-      if (plugin->sockv4 != NULL)
-        {
-          addrs[sockets_created] = (struct sockaddr*) &serverAddrv4;
-          addrlens[sockets_created] = sizeof (serverAddrv4);
-          sockets_created++;
-        }
+      tries++;
+      if (tries > 10)
+      {
+        GNUNET_NETWORK_socket_close (plugin->sockv4);
+        plugin->sockv4 = NULL;
+        break;
+      }
     }
+    if (plugin->sockv4 != NULL)
+    {
+      addrs[sockets_created] = (struct sockaddr *) &serverAddrv4;
+      addrlens[sockets_created] = sizeof (serverAddrv4);
+      sockets_created++;
+    }
+  }
 
   plugin->rs = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_zero (plugin->rs);
   if (NULL != plugin->sockv4)
-    GNUNET_NETWORK_fdset_set (plugin->rs,
-                              plugin->sockv4);
+    GNUNET_NETWORK_fdset_set (plugin->rs, plugin->sockv4);
   if (NULL != plugin->sockv6)
-    GNUNET_NETWORK_fdset_set (plugin->rs,
-                              plugin->sockv6);
+    GNUNET_NETWORK_fdset_set (plugin->rs, plugin->sockv6);
 
   plugin->select_task =
-    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                 GNUNET_SCHEDULER_NO_TASK,
-                                 GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
-                                 NULL, &udp_plugin_select, plugin);
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                   GNUNET_SCHEDULER_NO_TASK,
+                                   GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
+                                   NULL, &udp_plugin_select, plugin);
   if (sockets_created == 0)
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Failed to open UDP sockets\n"));
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _("Failed to open UDP sockets\n"));
   plugin->nat = GNUNET_NAT_register (env->cfg,
-                                     GNUNET_NO,
-                                     port,
-                                     sockets_created,
-                                     (const struct sockaddr**) addrs, addrlens,
-                                     &udp_nat_port_map_callback, 
-                                     NULL,
-                                     plugin);
+                                     GNUNET_NO,
+                                     port,
+                                     sockets_created,
+                                     (const struct sockaddr **) addrs, addrlens,
+                                     &udp_nat_port_map_callback, NULL, plugin);
   return api;
 }
 
@@ -1575,9 +1510,7 @@ libgnunet_plugin_transport_udp_init (void *cls)
  * @return GNUNET_OK (continue to iterate)
  */
 static int
-destroy_session (void *cls,
-                 const GNUNET_HashCode *key,
-                 void *value)
+destroy_session (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct PeerSession *peer_session = value;
 
@@ -1602,32 +1535,31 @@ libgnunet_plugin_transport_udp_done (void *cls)
 
   /* FIXME: clean up heap and hashmap */
   GNUNET_CONTAINER_multihashmap_iterate (plugin->sessions,
-                                         &destroy_session,
-                                         NULL);
+                                         &destroy_session, NULL);
   GNUNET_CONTAINER_multihashmap_destroy (plugin->sessions);
   plugin->sessions = NULL;
   while (NULL != (rc = GNUNET_CONTAINER_heap_remove_root (plugin->defrags)))
-    {
-      GNUNET_DEFRAGMENT_context_destroy (rc->defrag);
-      GNUNET_free (rc);
-    }
+  {
+    GNUNET_DEFRAGMENT_context_destroy (rc->defrag);
+    GNUNET_free (rc);
+  }
   GNUNET_CONTAINER_heap_destroy (plugin->defrags);
-  
+
   if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (plugin->select_task);
-      plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (plugin->select_task);
+    plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (plugin->sockv4 != NULL)
-    {
-      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv4));
-      plugin->sockv4 = NULL;
-    }
+  {
+    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv4));
+    plugin->sockv4 = NULL;
+  }
   if (plugin->sockv6 != NULL)
-    {
-      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv6));
-      plugin->sockv6 = NULL;
-    }
+  {
+    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->sockv6));
+    plugin->sockv6 = NULL;
+  }
   GNUNET_SERVER_mst_destroy (plugin->mst);
   GNUNET_NETWORK_fdset_destroy (plugin->rs);
   GNUNET_NAT_unregister (plugin->nat);