1 files changed, 283 insertions, 299 deletions

diff --git a/src/transport/plugin_transport_unix.c b/src/transport/plugin_transport_unix.c
index 2a7dc9065..22dda8e8b 100644
--- a/src/transport/plugin_transport_unix.c
+++ b/src/transport/plugin_transport_unix.c
@@ -375,26 +375,27 @@ unix_transport_server_stop (void *cls)
 
   pos = retry_list_head;
 
-  while(NULL != (pos = retry_list_head))
+  while (NULL != (pos = retry_list_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (retry_list_head, retry_list_tail, pos);
+    if (GNUNET_SCHEDULER_NO_TASK != pos->retry_ctx->retry_task)
     {
-      GNUNET_CONTAINER_DLL_remove(retry_list_head, retry_list_tail, pos);
-      if (GNUNET_SCHEDULER_NO_TASK != pos->retry_ctx->retry_task)
-        {
-          GNUNET_SCHEDULER_cancel(pos->retry_ctx->retry_task);
-        }
-      GNUNET_free(pos->retry_ctx->msg);
-      GNUNET_free(pos->retry_ctx->addr);
-      GNUNET_free(pos->retry_ctx);
-      GNUNET_free(pos);
+      GNUNET_SCHEDULER_cancel (pos->retry_ctx->retry_task);
     }
+    GNUNET_free (pos->retry_ctx->msg);
+    GNUNET_free (pos->retry_ctx->addr);
+    GNUNET_free (pos->retry_ctx);
+    GNUNET_free (pos);
+  }
 
   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;
+  }
 
-  GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (plugin->unix_sock.desc));
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_NETWORK_socket_close (plugin->unix_sock.desc));
   plugin->unix_sock.desc = NULL;
 
   return GNUNET_OK;
@@ -402,18 +403,17 @@ unix_transport_server_stop (void *cls)
 
 
 struct PeerSession *
-find_session (struct Plugin *plugin,
-              const struct GNUNET_PeerIdentity *peer)
+find_session (struct Plugin *plugin, const struct GNUNET_PeerIdentity *peer)
 {
   struct PeerSession *pos;
 
   pos = plugin->sessions;
   while (pos != NULL)
-    {
-      if (memcmp(&pos->target, peer, sizeof(struct GNUNET_PeerIdentity)) == 0)
-        return pos;
-      pos = pos->next;
-    }
+  {
+    if (memcmp (&pos->target, peer, sizeof (struct GNUNET_PeerIdentity)) == 0)
+      return pos;
+    pos = pos->next;
+  }
 
   return pos;
 }
@@ -430,8 +430,7 @@ unix_real_send (void *cls,
                 struct GNUNET_TIME_Relative timeout,
                 const void *addr,
                 size_t addrlen,
-                GNUNET_TRANSPORT_TransmitContinuation cont,
-                void *cont_cls);
+                GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls);
 
 /**
  * Retry sending a message.
@@ -439,18 +438,18 @@ unix_real_send (void *cls,
  * @param cls closure a struct RetrySendContext
  * @param tc context information
  */
-void retry_send_message (void *cls,
-                         const struct GNUNET_SCHEDULER_TaskContext * tc)
+void
+retry_send_message (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct RetrySendContext *retry_ctx = cls;
 
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-    {
-      GNUNET_free(retry_ctx->msg);
-      GNUNET_free(retry_ctx->addr);
-      GNUNET_free(retry_ctx);
-      return;
-    }
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+  {
+    GNUNET_free (retry_ctx->msg);
+    GNUNET_free (retry_ctx->addr);
+    GNUNET_free (retry_ctx);
+    return;
+  }
 
   unix_real_send (retry_ctx->plugin,
                   retry_ctx,
@@ -461,9 +460,7 @@ void retry_send_message (void *cls,
                   retry_ctx->priority,
                   GNUNET_TIME_absolute_get_remaining (retry_ctx->timeout),
                   retry_ctx->addr,
-                  retry_ctx->addrlen,
-                  retry_ctx->cont,
-                  retry_ctx->cont_cls);
+                  retry_ctx->addrlen, retry_ctx->cont, retry_ctx->cont_cls);
   return;
 }
 
@@ -493,15 +490,14 @@ static ssize_t
 unix_real_send (void *cls,
                 struct RetrySendContext *incoming_retry_context,
                 struct GNUNET_NETWORK_Handle *send_handle,
-                const struct GNUNET_PeerIdentity *target,
-                const char *msgbuf,
-                size_t msgbuf_size,
-                unsigned int priority,
-                struct GNUNET_TIME_Relative timeout,
-                const void *addr,
-                size_t addrlen,
-                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,
+                const void *addr,
+                size_t addrlen,
+                GNUNET_TRANSPORT_TransmitContinuation cont, void *cont_cls)
 {
   struct Plugin *plugin = cls;
   struct UNIXMessage *message;
@@ -516,26 +512,26 @@ unix_real_send (void *cls,
   int retry;
 
   if (send_handle == NULL)
-    {
+  {
 #if DEBUG_UNIX
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                       "unix_real_send with send_handle NULL!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "unix_real_send with send_handle NULL!\n");
 #endif
-      /* failed to open send socket for AF */
-      if (cont != NULL)
-        cont (cont_cls, target, GNUNET_SYSERR);
-      return 0;
-    }
+    /* failed to open send socket for AF */
+    if (cont != NULL)
+      cont (cont_cls, target, GNUNET_SYSERR);
+    return 0;
+  }
   if ((addr == NULL) || (addrlen == 0))
-    {
+  {
 #if DEBUG_UNIX
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                       "unix_real_send called without address, returning!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "unix_real_send called without address, returning!\n");
 #endif
-      if (cont != NULL)
-        cont (cont_cls, target, GNUNET_SYSERR);
-      return 0; /* Can never send if we don't have an address!! */
-    }
+    if (cont != NULL)
+      cont (cont_cls, target, GNUNET_SYSERR);
+    return 0;                   /* Can never send if we don't have an address!! */
+  }
 
   /* Build the message to be sent */
   message = GNUNET_malloc (sizeof (struct UNIXMessage) + msgbuf_size);
@@ -547,13 +543,13 @@ unix_real_send (void *cls,
           sizeof (struct GNUNET_PeerIdentity));
   memcpy (&message[1], msgbuf, msgbuf_size);
 
-  memset(&un, 0, sizeof(un));
+  memset (&un, 0, sizeof (un));
   un.sun_family = AF_UNIX;
   slen = strlen (addr) + 1;
   if (slen >= sizeof (un.sun_path))
     slen = sizeof (un.sun_path) - 1;
   sent = 0;
-  GNUNET_assert(slen < sizeof(un.sun_path));
+  GNUNET_assert (slen < sizeof (un.sun_path));
   memcpy (un.sun_path, addr, slen);
   un.sun_path[slen] = '\0';
   slen = sizeof (struct sockaddr_un);
@@ -563,104 +559,105 @@ unix_real_send (void *cls,
 #if HAVE_SOCKADDR_IN_SIN_LEN
   un.sun_len = (u_char) slen;
 #endif
-  sb = (struct sockaddr*) &un;
+  sb = (struct sockaddr *) &un;
   sbs = slen;
   retry = GNUNET_NO;
 
-  sent = GNUNET_NETWORK_socket_sendto(send_handle, message, ssize, sb, sbs);
+  sent = GNUNET_NETWORK_socket_sendto (send_handle, message, ssize, sb, sbs);
 
   if ((GNUNET_SYSERR == sent) && (errno == EAGAIN))
-          retry = GNUNET_YES;
+    retry = GNUNET_YES;
 
   if ((GNUNET_SYSERR == sent) && (errno == EMSGSIZE))
   {
-          socklen_t size = 0;
-          socklen_t len = sizeof (size);
-          GNUNET_NETWORK_socket_getsockopt ((struct GNUNET_NETWORK_Handle * ) send_handle,
-                          SOL_SOCKET,
-                          SO_SNDBUF,
-                          &size, &len);
-
-          if (size < ssize)
-          {
+    socklen_t size = 0;
+    socklen_t len = sizeof (size);
+
+    GNUNET_NETWORK_socket_getsockopt ((struct GNUNET_NETWORK_Handle *)
+                                      send_handle, SOL_SOCKET, SO_SNDBUF, &size,
+                                      &len);
+
+    if (size < ssize)
+    {
 #if DEBUG_UNIX
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Trying to increase socket buffer size from %i to %i for message size %i\n",
-              size,
-              ((ssize / 1000) + 2) * 1000, ssize);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Trying to increase socket buffer size from %i to %i for message size %i\n",
+                  size, ((ssize / 1000) + 2) * 1000, ssize);
 #endif
-                  size = ((ssize / 1000) + 2) * 1000;
-                  if (GNUNET_NETWORK_socket_setsockopt ((struct GNUNET_NETWORK_Handle * ) send_handle,
-                                  SOL_SOCKET,
-                                  SO_SNDBUF,
-                                  &size, sizeof(size)) == GNUNET_OK)
-                         retry = GNUNET_YES;
-                  else
-                         GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "setsockopt");
-          }
+      size = ((ssize / 1000) + 2) * 1000;
+      if (GNUNET_NETWORK_socket_setsockopt
+          ((struct GNUNET_NETWORK_Handle *) send_handle, SOL_SOCKET, SO_SNDBUF,
+           &size, sizeof (size)) == GNUNET_OK)
+        retry = GNUNET_YES;
+      else
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "setsockopt");
+    }
   }
 
   if (retry == GNUNET_YES)
+  {
+    if (incoming_retry_context == NULL)
     {
-      if (incoming_retry_context == NULL)
-        {
-          retry_list_entry = GNUNET_malloc(sizeof(struct RetryList));
-          retry_ctx = GNUNET_malloc(sizeof(struct RetrySendContext));
-          retry_ctx->addr = GNUNET_malloc(addrlen);
-          retry_ctx->msg = GNUNET_malloc(msgbuf_size);
-          retry_ctx->plugin = plugin;
-          memcpy(retry_ctx->addr, addr, addrlen);
-          memcpy(retry_ctx->msg, msgbuf, msgbuf_size);
-          retry_ctx->msg_size = msgbuf_size;
-          retry_ctx->addrlen = addrlen;
-          retry_ctx->send_handle = send_handle;
-          retry_ctx->cont = cont;
-          retry_ctx->cont_cls = cont_cls;
-          retry_ctx->priority = priority;
-          retry_ctx->timeout = GNUNET_TIME_relative_to_absolute(timeout);
-          memcpy(&retry_ctx->target, target, sizeof(struct GNUNET_PeerIdentity));
-          retry_ctx->delay = GNUNET_TIME_UNIT_MILLISECONDS;
-          retry_ctx->retry_list_entry = retry_list_entry;
-          retry_list_entry->retry_ctx = retry_ctx;
-          GNUNET_CONTAINER_DLL_insert(retry_list_head, retry_list_tail, retry_list_entry);
-        }
-      else
-        {
-          retry_ctx = incoming_retry_context;
-          retry_ctx->delay = GNUNET_TIME_relative_multiply(retry_ctx->delay, 2);
-        }
-      retry_ctx->retry_task = GNUNET_SCHEDULER_add_delayed(retry_ctx->delay, &retry_send_message, retry_ctx);
-
-      //GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "send");
-      GNUNET_free(message);
-      return ssize;
+      retry_list_entry = GNUNET_malloc (sizeof (struct RetryList));
+      retry_ctx = GNUNET_malloc (sizeof (struct RetrySendContext));
+      retry_ctx->addr = GNUNET_malloc (addrlen);
+      retry_ctx->msg = GNUNET_malloc (msgbuf_size);
+      retry_ctx->plugin = plugin;
+      memcpy (retry_ctx->addr, addr, addrlen);
+      memcpy (retry_ctx->msg, msgbuf, msgbuf_size);
+      retry_ctx->msg_size = msgbuf_size;
+      retry_ctx->addrlen = addrlen;
+      retry_ctx->send_handle = send_handle;
+      retry_ctx->cont = cont;
+      retry_ctx->cont_cls = cont_cls;
+      retry_ctx->priority = priority;
+      retry_ctx->timeout = GNUNET_TIME_relative_to_absolute (timeout);
+      memcpy (&retry_ctx->target, target, sizeof (struct GNUNET_PeerIdentity));
+      retry_ctx->delay = GNUNET_TIME_UNIT_MILLISECONDS;
+      retry_ctx->retry_list_entry = retry_list_entry;
+      retry_list_entry->retry_ctx = retry_ctx;
+      GNUNET_CONTAINER_DLL_insert (retry_list_head, retry_list_tail,
+                                   retry_list_entry);
     }
+    else
+    {
+      retry_ctx = incoming_retry_context;
+      retry_ctx->delay = GNUNET_TIME_relative_multiply (retry_ctx->delay, 2);
+    }
+    retry_ctx->retry_task =
+        GNUNET_SCHEDULER_add_delayed (retry_ctx->delay, &retry_send_message,
+                                      retry_ctx);
+
+    //GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "send");
+    GNUNET_free (message);
+    return ssize;
+  }
 #if DEBUG_UNIX
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "UNIX transmit %u-byte message to %s (%d: %s)\n",
-              (unsigned int) ssize,
-              GNUNET_a2s (sb, sbs),
-              (int) sent,
-              (sent < 0) ? STRERROR (errno) : "ok");
+              "UNIX transmit %u-byte message to %s (%d: %s)\n",
+              (unsigned int) ssize,
+              GNUNET_a2s (sb, sbs),
+              (int) sent, (sent < 0) ? STRERROR (errno) : "ok");
 #endif
   if (cont != NULL)
+  {
+    if (sent == GNUNET_SYSERR)
+      cont (cont_cls, target, GNUNET_SYSERR);
+    else
     {
-      if (sent == GNUNET_SYSERR)
-        cont (cont_cls, target, GNUNET_SYSERR);
-      else
-        {
-          cont (cont_cls, target, GNUNET_OK);
-        }
+      cont (cont_cls, target, GNUNET_OK);
     }
+  }
 
   if (incoming_retry_context != NULL)
-    {
-      GNUNET_CONTAINER_DLL_remove(retry_list_head, retry_list_tail, incoming_retry_context->retry_list_entry);
-      GNUNET_free(incoming_retry_context->retry_list_entry);
-      GNUNET_free(incoming_retry_context->msg);
-      GNUNET_free(incoming_retry_context->addr);
-      GNUNET_free(incoming_retry_context);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (retry_list_head, retry_list_tail,
+                                 incoming_retry_context->retry_list_entry);
+    GNUNET_free (incoming_retry_context->retry_list_entry);
+    GNUNET_free (incoming_retry_context->msg);
+    GNUNET_free (incoming_retry_context->addr);
+    GNUNET_free (incoming_retry_context);
+  }
 
   GNUNET_free (message);
   return sent;
@@ -693,16 +690,16 @@ unix_real_send (void *cls,
  */
 static ssize_t
 unix_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;
   ssize_t sent;
@@ -712,17 +709,18 @@ unix_plugin_send (void *cls,
   GNUNET_assert (NULL == session);
 
 #if DEBUG_UNIX
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Asked to send message to `%s'\n", (char *)addr);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asked to send message to `%s'\n",
+              (char *) addr);
 #endif
-  sent = unix_real_send(cls,
-                        NULL,
-                        plugin->unix_sock.desc,
-                        target,
-                        msgbuf, msgbuf_size,
-                        priority, timeout, addr, addrlen,
-                        cont, cont_cls);
+  sent = unix_real_send (cls,
+                         NULL,
+                         plugin->unix_sock.desc,
+                         target,
+                         msgbuf, msgbuf_size,
+                         priority, timeout, addr, addrlen, cont, cont_cls);
 #if DEBUG_UNIX
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sent %d bytes to `%s'\n", sent, (char *)addr);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sent %d bytes to `%s'\n", sent,
+              (char *) addr);
 #endif
   if (sent == GNUNET_SYSERR)
     return 0;
@@ -740,11 +738,10 @@ unix_plugin_send (void *cls,
  * @param fromlen the length of the address
  */
 static void
-unix_demultiplexer(struct Plugin *plugin,
-                   struct GNUNET_PeerIdentity *sender,
-                   const struct GNUNET_MessageHeader *currhdr,
-                   const struct sockaddr_un *un,
-                   size_t fromlen)
+unix_demultiplexer (struct Plugin *plugin,
+                    struct GNUNET_PeerIdentity *sender,
+                    const struct GNUNET_MessageHeader *currhdr,
+                    const struct sockaddr_un *un, size_t fromlen)
 {
   struct GNUNET_TRANSPORT_ATS_Information distance[2];
 
@@ -753,14 +750,16 @@ unix_demultiplexer(struct Plugin *plugin,
   distance[1].type = htonl (GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR);
   distance[1].value = htonl (0);
 
-  GNUNET_assert(fromlen >= sizeof(struct sockaddr_un));
+  GNUNET_assert (fromlen >= sizeof (struct sockaddr_un));
 
 #if DEBUG_UNIX
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received message from %s\n", un->sun_path);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received message from %s\n",
+              un->sun_path);
 #endif
   plugin->env->receive (plugin->env->cls, sender, currhdr,
-                       (const struct GNUNET_TRANSPORT_ATS_Information *) &distance, 2,
-                              NULL, un->sun_path, strlen(un->sun_path) + 1);
+                        (const struct GNUNET_TRANSPORT_ATS_Information *)
+                        &distance, 2, NULL, un->sun_path,
+                        strlen (un->sun_path) + 1);
 }
 
 
@@ -774,8 +773,7 @@ unix_demultiplexer(struct Plugin *plugin,
  *
  */
 static void
-unix_plugin_select (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+unix_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct Plugin *plugin = cls;
   char buf[65536];
@@ -791,33 +789,35 @@ unix_plugin_select (void *cls,
   uint16_t csize;
 
   plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
     return;
 
-  addrlen = sizeof(un);
-  memset(&un, 0, sizeof(un));
-  GNUNET_assert (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->unix_sock.desc));
+  addrlen = sizeof (un);
+  memset (&un, 0, sizeof (un));
+  GNUNET_assert (GNUNET_NETWORK_fdset_isset
+                 (tc->read_ready, plugin->unix_sock.desc));
   ret =
-    GNUNET_NETWORK_socket_recvfrom (plugin->unix_sock.desc, buf, sizeof (buf),
-                                    (struct sockaddr *)&un, &addrlen);
+      GNUNET_NETWORK_socket_recvfrom (plugin->unix_sock.desc, buf, sizeof (buf),
+                                      (struct sockaddr *) &un, &addrlen);
 
   if (ret == GNUNET_SYSERR)
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "recvfrom");
-      plugin->select_task =
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "recvfrom");
+    plugin->select_task =
         GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                      GNUNET_SCHEDULER_NO_TASK,
                                      GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
                                      NULL, &unix_plugin_select, plugin);
-      return;
-    }
+    return;
+  }
   else
   {
 #if LINUX
     un.sun_path[0] = '/';
 #endif
 #if DEBUG_UNIX
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Read %d bytes from socket %s\n", ret, &un.sun_path[0]);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Read %d bytes from socket %s\n", ret,
+                &un.sun_path[0]);
 #endif
   }
 
@@ -825,40 +825,38 @@ unix_plugin_select (void *cls,
 
   msg = (struct UNIXMessage *) buf;
   csize = ntohs (msg->header.size);
-  if ( (csize < sizeof (struct UNIXMessage)) ||
-       (csize > ret) )
-    {
-      GNUNET_break_op (0);
-      plugin->select_task =
-        GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                     GNUNET_SCHEDULER_NO_TASK,
-                                     GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
-                                     NULL, &unix_plugin_select, plugin);
-      return;
-    }
-  msgbuf = (char *)&msg[1];
+  if ((csize < sizeof (struct UNIXMessage)) || (csize > ret))
+  {
+    GNUNET_break_op (0);
+    plugin->select_task =
+        GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                     GNUNET_SCHEDULER_NO_TASK,
+                                     GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
+                                     NULL, &unix_plugin_select, plugin);
+    return;
+  }
+  msgbuf = (char *) &msg[1];
   memcpy (&sender, &msg->sender, sizeof (struct GNUNET_PeerIdentity));
   offset = 0;
   tsize = csize - sizeof (struct UNIXMessage);
   while (offset + sizeof (struct GNUNET_MessageHeader) <= tsize)
+  {
+    currhdr = (struct GNUNET_MessageHeader *) &msgbuf[offset];
+    csize = ntohs (currhdr->size);
+    if ((csize < sizeof (struct GNUNET_MessageHeader)) ||
+        (csize > tsize - offset))
     {
-      currhdr = (struct GNUNET_MessageHeader *)&msgbuf[offset];
-      csize = ntohs (currhdr->size);
-      if ( (csize < sizeof (struct GNUNET_MessageHeader)) ||
-           (csize > tsize - offset) )
-        {
-          GNUNET_break_op (0);
-          break;
-        }
-      unix_demultiplexer(plugin, &sender, currhdr,
-                         &un, sizeof(un));
-      offset += csize;
+      GNUNET_break_op (0);
+      break;
     }
+    unix_demultiplexer (plugin, &sender, currhdr, &un, sizeof (un));
+    offset += csize;
+  }
   plugin->select_task =
-    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                 GNUNET_SCHEDULER_NO_TASK,
-                                 GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
-                                 NULL, &unix_plugin_select, plugin);
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                   GNUNET_SCHEDULER_NO_TASK,
+                                   GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
+                                   NULL, &unix_plugin_select, plugin);
 }
 
 /**
@@ -876,7 +874,7 @@ unix_transport_server_start (void *cls)
   struct sockaddr_un un;
   size_t slen;
 
-  memset(&un, 0, sizeof(un));
+  memset (&un, 0, sizeof (un));
   un.sun_family = AF_UNIX;
   slen = strlen (plugin->unix_socket_path) + 1;
   if (slen >= sizeof (un.sun_path))
@@ -889,42 +887,40 @@ unix_transport_server_start (void *cls)
   un.sun_len = (u_char) slen;
 #endif
 
-  serverAddr = (struct sockaddr*) &un;
+  serverAddr = (struct sockaddr *) &un;
   addrlen = slen;
 #if LINUX
   un.sun_path[0] = '\0';
 #endif
 
-  plugin->unix_sock.desc = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_DGRAM, 0);
+  plugin->unix_sock.desc =
+      GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_DGRAM, 0);
   if (NULL == plugin->unix_sock.desc)
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
-      return GNUNET_SYSERR;
-    }
-  if (GNUNET_NETWORK_socket_bind (plugin->unix_sock.desc, serverAddr, addrlen) !=
-      GNUNET_OK)
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
-      GNUNET_NETWORK_socket_close (plugin->unix_sock.desc);
-      plugin->unix_sock.desc = NULL;
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
+    return GNUNET_SYSERR;
+  }
+  if (GNUNET_NETWORK_socket_bind (plugin->unix_sock.desc, serverAddr, addrlen)
+      != GNUNET_OK)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
+    GNUNET_NETWORK_socket_close (plugin->unix_sock.desc);
+    plugin->unix_sock.desc = NULL;
+    return GNUNET_SYSERR;
+  }
 #if DEBUG_UNIX
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, 
-                   "unix",
-                   "Bound to `%s'\n",
-                   &un.sun_path[0]);
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                   "unix", "Bound to `%s'\n", &un.sun_path[0]);
 #endif
   plugin->rs = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_zero (plugin->rs);
-  GNUNET_NETWORK_fdset_set (plugin->rs,
-                            plugin->unix_sock.desc);
+  GNUNET_NETWORK_fdset_set (plugin->rs, plugin->unix_sock.desc);
 
   plugin->select_task =
-    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                 GNUNET_SCHEDULER_NO_TASK,
-                                 GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
-                                 NULL, &unix_plugin_select, plugin);
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                   GNUNET_SCHEDULER_NO_TASK,
+                                   GNUNET_TIME_UNIT_FOREVER_REL, plugin->rs,
+                                   NULL, &unix_plugin_select, plugin);
   return 1;
 }
 
@@ -946,15 +942,13 @@ unix_transport_server_start (void *cls)
  *
  */
 static int
-unix_check_address (void *cls,
-                   const void *addr,
-                   size_t addrlen)
+unix_check_address (void *cls, const void *addr, size_t addrlen)
 {
 
 #if DEBUG_UNIX
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                   "Informing transport service about my address `%s'\n",
-                   (char *)addr);
+              "Informing transport service about my address `%s'\n",
+              (char *) addr);
 #endif
   return GNUNET_OK;
 }
@@ -970,11 +964,11 @@ append_port (void *cls, const char *hostname)
   char *ret;
 
   if (hostname == NULL)
-    {
-      ppc->asc (ppc->asc_cls, NULL);
-      GNUNET_free (ppc);
-      return;
-    }
+  {
+    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);
@@ -997,13 +991,13 @@ append_port (void *cls, const char *hostname)
  */
 static void
 unix_plugin_address_pretty_printer (void *cls,
-                                   const char *type,
-                                   const void *addr,
-                                   size_t addrlen,
-                                   int numeric,
-                                   struct GNUNET_TIME_Relative timeout,
-                                   GNUNET_TRANSPORT_AddressStringCallback asc,
-                                   void *asc_cls)
+                                    const char *type,
+                                    const void *addr,
+                                    size_t addrlen,
+                                    int numeric,
+                                    struct GNUNET_TIME_Relative timeout,
+                                    GNUNET_TRANSPORT_AddressStringCallback asc,
+                                    void *asc_cls)
 {
   struct PrettyPrinterContext *ppc;
   const void *sb;
@@ -1015,43 +1009,39 @@ unix_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;
-      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);
-    }
+  {
+    u6 = addr;
+    memset (&a6, 0, sizeof (a6));
+    a6.sin6_family = AF_INET6;
+    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;
-      a4.sin_port = u4->u_port;
-      a4.sin_addr.s_addr = u4->ipv4_addr;
-      port = ntohs (u4->u_port);
-      sb = &a4;
-      sbs = sizeof (a4);
-    }
+  {
+    u4 = addr;
+    memset (&a4, 0, sizeof (a4));
+    a4.sin_family = AF_INET;
+    a4.sin_port = u4->u_port;
+    a4.sin_addr.s_addr = u4->ipv4_addr;
+    port = ntohs (u4->u_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);
 }
 
 /**
@@ -1065,10 +1055,8 @@ unix_plugin_address_pretty_printer (void *cls,
  * @param addrlen length of the address
  * @return string representing the same address
  */
-static const char*
-unix_address_to_string (void *cls,
-                       const void *addr,
-                       size_t addrlen)
+static const char *
+unix_address_to_string (void *cls, const void *addr, size_t addrlen)
 {
   if ((addr != NULL) && (addrlen > 0))
     return (const char *) addr;
@@ -1083,14 +1071,14 @@ unix_address_to_string (void *cls,
  * @param tc unused
  */
 static void
-address_notification (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+address_notification (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct Plugin *plugin = cls;
-  plugin->env->notify_address(plugin->env->cls,
-                              GNUNET_YES,
-                              plugin->unix_socket_path,
-                              strlen(plugin->unix_socket_path) + 1);
+
+  plugin->env->notify_address (plugin->env->cls,
+                               GNUNET_YES,
+                               plugin->unix_socket_path,
+                               strlen (plugin->unix_socket_path) + 1);
 }
 
 /**
@@ -1108,17 +1096,14 @@ libgnunet_plugin_transport_unix_init (void *cls)
 
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (env->cfg,
-                                             "transport-unix",
-                                             "PORT",
-                                             &port))
+                                             "transport-unix", "PORT", &port))
     port = UNIX_NAT_DEFAULT_PORT;
   plugin = GNUNET_malloc (sizeof (struct Plugin));
   plugin->port = port;
   plugin->env = env;
-  GNUNET_asprintf (&plugin->unix_socket_path, 
-                   "/tmp/unix-plugin-sock.%d", 
-                   plugin->port);
-  
+  GNUNET_asprintf (&plugin->unix_socket_path,
+                   "/tmp/unix-plugin-sock.%d", plugin->port);
+
   api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions));
   api->cls = plugin;
 
@@ -1129,10 +1114,9 @@ libgnunet_plugin_transport_unix_init (void *cls)
   api->check_address = &unix_check_address;
   sockets_created = unix_transport_server_start (plugin);
   if (sockets_created == 0)
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Failed to open UNIX sockets\n"));
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _("Failed to open UNIX sockets\n"));
 
-  GNUNET_SCHEDULER_add_now(address_notification, plugin);
+  GNUNET_SCHEDULER_add_now (address_notification, plugin);
   return api;
 }