1 files changed, 400 insertions, 417 deletions

diff --git a/src/util/client.c b/src/util/client.c
index db53ab6f2..032a6c5e4 100644
--- a/src/util/client.c
+++ b/src/util/client.c
@@ -243,7 +243,7 @@ struct GNUNET_CLIENT_Connection
    * Are we ignoring shutdown signals?
    */
   int ignore_shutdown;
-  
+
   /**
    * How often have we tried to connect?
    */
@@ -262,8 +262,7 @@ struct GNUNET_CLIENT_Connection
  */
 static struct GNUNET_CONNECTION_Handle *
 do_connect (const char *service_name,
-            const struct GNUNET_CONFIGURATION_Handle *cfg,
-            unsigned int attempt)
+            const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned int attempt)
 {
   struct GNUNET_CONNECTION_Handle *sock;
   char *hostname;
@@ -273,27 +272,24 @@ do_connect (const char *service_name,
   sock = NULL;
 #if AF_UNIX
   if (0 == (attempt % 2))
+  {
+    /* on even rounds, try UNIX */
+    unixpath = NULL;
+    if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, service_name, "UNIXPATH", &unixpath)) && (0 < strlen (unixpath)))     /* We have a non-NULL unixpath, does that mean it's valid? */
     {
-      /* on even rounds, try UNIX */
-      unixpath = NULL;
-      if ( (GNUNET_OK ==
-            GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                   service_name,
-                                                   "UNIXPATH", &unixpath)) &&
-           (0 < strlen (unixpath)) ) /* We have a non-NULL unixpath, does that mean it's valid? */
-        {
-          sock = GNUNET_CONNECTION_create_from_connect_to_unixpath (cfg, unixpath);
-          if (sock != NULL)
-            {
+      sock = GNUNET_CONNECTION_create_from_connect_to_unixpath (cfg, unixpath);
+      if (sock != NULL)
+      {
 #if DEBUG_CLIENT
-              GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connected to unixpath `%s'!\n", unixpath);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected to unixpath `%s'!\n",
+                    unixpath);
 #endif
-              GNUNET_free(unixpath);
-              return sock;
-            }
-        }
-      GNUNET_free_non_null (unixpath);
+        GNUNET_free (unixpath);
+        return sock;
+      }
     }
+    GNUNET_free_non_null (unixpath);
+  }
 #endif
 
   if ((GNUNET_OK !=
@@ -306,57 +302,56 @@ do_connect (const char *service_name,
        GNUNET_CONFIGURATION_get_value_string (cfg,
                                               service_name,
                                               "HOSTNAME", &hostname)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Could not determine valid hostname and port for service `%s' from configuration.\n"),
-                  service_name);
-      return NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _
+                ("Could not determine valid hostname and port for service `%s' from configuration.\n"),
+                service_name);
+    return NULL;
+  }
   if (0 == strlen (hostname))
-    {
-      GNUNET_free (hostname);
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Need a non-empty hostname for service `%s'.\n"),
-                  service_name);
-      return NULL;
-    }
+  {
+    GNUNET_free (hostname);
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("Need a non-empty hostname for service `%s'.\n"),
+                service_name);
+    return NULL;
+  }
   if (port == 0)
-    {
+  {
 #if AF_UNIX
-      if (0 != (attempt % 2))
-        {
-          /* try UNIX */
-          unixpath = NULL;
-          if ( (GNUNET_OK ==
-                GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                       service_name,
-                                                       "UNIXPATH", &unixpath)) &&
-               (0 < strlen (unixpath)))
-            {
-              sock = GNUNET_CONNECTION_create_from_connect_to_unixpath (cfg,
-                                                                        unixpath);
-              if (sock != NULL)
-                {
-                  GNUNET_free (unixpath);
-                  GNUNET_free (hostname);
-                  return sock;          
-                }
-            }
-          GNUNET_free_non_null (unixpath);
-        }
+    if (0 != (attempt % 2))
+    {
+      /* try UNIX */
+      unixpath = NULL;
+      if ((GNUNET_OK ==
+           GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                  service_name,
+                                                  "UNIXPATH", &unixpath)) &&
+          (0 < strlen (unixpath)))
+      {
+        sock = GNUNET_CONNECTION_create_from_connect_to_unixpath (cfg,
+                                                                  unixpath);
+        if (sock != NULL)
+        {
+          GNUNET_free (unixpath);
+          GNUNET_free (hostname);
+          return sock;
+        }
+      }
+      GNUNET_free_non_null (unixpath);
+    }
 #endif
 #if DEBUG_CLIENT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Port is 0 for service `%s', UNIXPATH did not work, returning NULL!\n",
-                  service_name);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Port is 0 for service `%s', UNIXPATH did not work, returning NULL!\n",
+                service_name);
 #endif
-      GNUNET_free (hostname);
-      return NULL;
-    }
+    GNUNET_free (hostname);
+    return NULL;
+  }
 
-  sock = GNUNET_CONNECTION_create_from_connect (cfg,
-                                                hostname,
-                                                port);
+  sock = GNUNET_CONNECTION_create_from_connect (cfg, hostname, port);
   GNUNET_free (hostname);
   return sock;
 }
@@ -376,8 +371,7 @@ GNUNET_CLIENT_connect (const char *service_name,
   struct GNUNET_CLIENT_Connection *ret;
   struct GNUNET_CONNECTION_Handle *sock;
 
-  sock = do_connect (service_name,
-                     cfg, 0);
+  sock = do_connect (service_name, cfg, 0);
   ret = GNUNET_malloc (sizeof (struct GNUNET_CLIENT_Connection));
   ret->attempts = 1;
   ret->sock = sock;
@@ -396,12 +390,11 @@ GNUNET_CLIENT_connect (const char *service_name,
  */
 void
 GNUNET_CLIENT_ignore_shutdown (struct GNUNET_CLIENT_Connection *h,
-                               int do_ignore)
+                               int do_ignore)
 {
   h->ignore_shutdown = do_ignore;
   if (h->sock != NULL)
-    GNUNET_CONNECTION_ignore_shutdown (h->sock,
-                                       do_ignore);
+    GNUNET_CONNECTION_ignore_shutdown (h->sock, do_ignore);
 }
 
 
@@ -422,33 +415,33 @@ GNUNET_CLIENT_ignore_shutdown (struct GNUNET_CLIENT_Connection *h,
  */
 void
 GNUNET_CLIENT_disconnect (struct GNUNET_CLIENT_Connection *sock,
-                          int finish_pending_write)
+                          int finish_pending_write)
 {
   if (sock->in_receive == GNUNET_YES)
-    {
-      GNUNET_CONNECTION_receive_cancel (sock->sock);
-      sock->in_receive = GNUNET_NO;
-    }
+  {
+    GNUNET_CONNECTION_receive_cancel (sock->sock);
+    sock->in_receive = GNUNET_NO;
+  }
   if (sock->th != NULL)
-    {
-      GNUNET_CLIENT_notify_transmit_ready_cancel (sock->th);
-      sock->th = NULL;
-    }
+  {
+    GNUNET_CLIENT_notify_transmit_ready_cancel (sock->th);
+    sock->th = NULL;
+  }
   if (NULL != sock->sock)
-    {
-      GNUNET_CONNECTION_destroy (sock->sock, finish_pending_write);
-      sock->sock = NULL;
-    }
+  {
+    GNUNET_CONNECTION_destroy (sock->sock, finish_pending_write);
+    sock->sock = NULL;
+  }
   if (sock->receive_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (sock->receive_task);
-      sock->receive_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (sock->receive_task);
+    sock->receive_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (sock->tag != NULL)
-    {
-      GNUNET_free (sock->tag);
-      sock->tag = NULL;
-    }
+  {
+    GNUNET_free (sock->tag);
+    sock->tag = NULL;
+  }
   sock->receiver_handler = NULL;
   GNUNET_array_grow (sock->received_buf, sock->received_size, 0);
   GNUNET_free (sock->service_name);
@@ -496,26 +489,25 @@ receive_helper (void *cls,
   GNUNET_assert (conn->msg_complete == GNUNET_NO);
   conn->in_receive = GNUNET_NO;
   if ((available == 0) || (conn->sock == NULL) || (errCode != 0))
-    {
-      /* signal timeout! */
+  {
+    /* signal timeout! */
 #if DEBUG_CLIENT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Timeout in receive_helper, available %u, conn->sock %s, errCode `%s'\n", 
-                  (unsigned int) available, 
-                  conn->sock == NULL ? "NULL" : "non-NULL", 
-                  STRERROR (errCode));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Timeout in receive_helper, available %u, conn->sock %s, errCode `%s'\n",
+                (unsigned int) available,
+                conn->sock == NULL ? "NULL" : "non-NULL", STRERROR (errCode));
 #endif
-      if (NULL != (receive_handler = conn->receiver_handler))
-        {
-          receive_handler_cls = conn->receiver_handler_cls;
-          conn->receiver_handler = NULL;
-          receive_handler (receive_handler_cls, NULL);
-        }
-      return;
+    if (NULL != (receive_handler = conn->receiver_handler))
+    {
+      receive_handler_cls = conn->receiver_handler_cls;
+      conn->receiver_handler = NULL;
+      receive_handler (receive_handler_cls, NULL);
     }
+    return;
+  }
 
   /* FIXME: optimize for common fast case where buf contains the
-     entire message and we need no copying... */
+   * entire message and we need no copying... */
 
 
   /* slow path: append to array */
@@ -528,12 +520,12 @@ receive_helper (void *cls,
   /* check for timeout */
   remaining = GNUNET_TIME_absolute_get_remaining (conn->receive_timeout);
   if (remaining.rel_value == 0)
-    {
-      /* signal timeout! */
-      if (NULL != conn->receiver_handler)
-        conn->receiver_handler (conn->receiver_handler_cls, NULL);
-      return;
-    }
+  {
+    /* signal timeout! */
+    if (NULL != conn->receiver_handler)
+      conn->receiver_handler (conn->receiver_handler_cls, NULL);
+    return;
+  }
   /* back to receive -- either for more data or to call callback! */
   GNUNET_CLIENT_receive (conn,
                          conn->receiver_handler,
@@ -553,7 +545,7 @@ receive_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct GNUNET_CLIENT_Connection *sock = cls;
   GNUNET_CLIENT_MessageHandler handler = sock->receiver_handler;
   const struct GNUNET_MessageHeader *cmsg =
-    (const struct GNUNET_MessageHeader *) sock->received_buf;
+      (const struct GNUNET_MessageHeader *) sock->received_buf;
   void *handler_cls = sock->receiver_handler_cls;
   uint16_t msize = ntohs (cmsg->size);
   char mbuf[msize];
@@ -561,9 +553,8 @@ receive_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 #if DEBUG_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received message of type %u and size %u\n",
-              ntohs (cmsg->type),
-              msize);
+              "Received message of type %u and size %u\n",
+              ntohs (cmsg->type), msize);
 #endif
   sock->receive_task = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_assert (GNUNET_YES == sock->msg_complete);
@@ -594,32 +585,32 @@ GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock,
                        void *handler_cls, struct GNUNET_TIME_Relative timeout)
 {
   if (sock->sock == NULL)
-    {
-      /* already disconnected, fail instantly! */
-      GNUNET_break (0);         /* this should not happen in well-written code! */
-      if (NULL != handler)
-        handler (handler_cls, NULL);
-      return;
-    }
+  {
+    /* already disconnected, fail instantly! */
+    GNUNET_break (0);           /* this should not happen in well-written code! */
+    if (NULL != handler)
+      handler (handler_cls, NULL);
+    return;
+  }
   sock->receiver_handler = handler;
   sock->receiver_handler_cls = handler_cls;
   sock->receive_timeout = GNUNET_TIME_relative_to_absolute (timeout);
   if (GNUNET_YES == sock->msg_complete)
-    {
-      GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sock->receive_task);
-      sock->receive_task = GNUNET_SCHEDULER_add_now (&receive_task, sock);
-    }
+  {
+    GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sock->receive_task);
+    sock->receive_task = GNUNET_SCHEDULER_add_now (&receive_task, sock);
+  }
   else
-    {
-      GNUNET_assert (sock->in_receive == GNUNET_NO);
-      sock->in_receive = GNUNET_YES;
+  {
+    GNUNET_assert (sock->in_receive == GNUNET_NO);
+    sock->in_receive = GNUNET_YES;
 #if DEBUG_CLIENT
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "calling GNUNET_CONNECTION_receive\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "calling GNUNET_CONNECTION_receive\n");
 #endif
-      GNUNET_CONNECTION_receive (sock->sock,
-                                 GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
-                                 timeout, &receive_helper, sock);
-    }
+    GNUNET_CONNECTION_receive (sock->sock,
+                               GNUNET_SERVER_MAX_MESSAGE_SIZE - 1,
+                               timeout, &receive_helper, sock);
+  }
 }
 
 
@@ -630,8 +621,7 @@ static void
 service_test_error (GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   GNUNET_SCHEDULER_add_continuation (task,
-                                     task_cls,
-                                     GNUNET_SCHEDULER_REASON_TIMEOUT);
+                                     task_cls, GNUNET_SCHEDULER_REASON_TIMEOUT);
 }
 
 
@@ -645,23 +635,24 @@ static void
 confirm_handler (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_CLIENT_Connection *conn = cls;
+
   /* We may want to consider looking at the reply in more
-     detail in the future, for example, is this the
-     correct service? FIXME! */
+   * detail in the future, for example, is this the
+   * correct service? FIXME! */
   if (msg != NULL)
-    {
+  {
 #if DEBUG_CLIENT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received confirmation that service is running.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received confirmation that service is running.\n");
 #endif
-      GNUNET_SCHEDULER_add_continuation (conn->test_cb,
-                                         conn->test_cb_cls,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-    }
+    GNUNET_SCHEDULER_add_continuation (conn->test_cb,
+                                       conn->test_cb_cls,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+  }
   else
-    {
-      service_test_error (conn->test_cb, conn->test_cb_cls);
-    }
+  {
+    service_test_error (conn->test_cb, conn->test_cb_cls);
+  }
   GNUNET_CLIENT_disconnect (conn, GNUNET_NO);
 }
 
@@ -682,26 +673,26 @@ write_test (void *cls, size_t size, void *buf)
   struct GNUNET_MessageHeader *msg;
 
   if (size < sizeof (struct GNUNET_MessageHeader))
-    {
+  {
 #if DEBUG_CLIENT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  _("Failure to transmit TEST request.\n"));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                _("Failure to transmit TEST request.\n"));
 #endif
-      service_test_error (conn->test_cb, conn->test_cb_cls);
-      GNUNET_CLIENT_disconnect (conn, GNUNET_NO);
-      return 0;                 /* client disconnected */
-    }
+    service_test_error (conn->test_cb, conn->test_cb_cls);
+    GNUNET_CLIENT_disconnect (conn, GNUNET_NO);
+    return 0;                   /* client disconnected */
+  }
 #if DEBUG_CLIENT
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transmitting `%s' request.\n", "TEST");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmitting `%s' request.\n", "TEST");
 #endif
   msg = (struct GNUNET_MessageHeader *) buf;
   msg->type = htons (GNUNET_MESSAGE_TYPE_TEST);
   msg->size = htons (sizeof (struct GNUNET_MessageHeader));
-  GNUNET_CLIENT_receive (conn, 
-                         &confirm_handler, 
-                         conn, 
-                         GNUNET_TIME_absolute_get_remaining (conn->test_deadline));
+  GNUNET_CLIENT_receive (conn,
+                         &confirm_handler,
+                         conn,
+                         GNUNET_TIME_absolute_get_remaining
+                         (conn->test_deadline));
   return sizeof (struct GNUNET_MessageHeader);
 }
 
@@ -740,60 +731,53 @@ GNUNET_CLIENT_service_test (const char *service,
     struct sockaddr_un s_un;
     size_t slen;
     char *unixpath;
-    
+
     unixpath = NULL;
-    if ( (GNUNET_OK ==
-          GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                 service,
-                                                 "UNIXPATH", &unixpath)) &&
-         (0 < strlen (unixpath)) ) /* We have a non-NULL unixpath, does that mean it's valid? */
+    if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, service, "UNIXPATH", &unixpath)) && (0 < strlen (unixpath)))  /* We have a non-NULL unixpath, does that mean it's valid? */
+    {
+      if (strlen (unixpath) >= sizeof (s_un.sun_path))
       {
-        if (strlen(unixpath) >= sizeof(s_un.sun_path))
-          {
-            GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                        _("UNIXPATH `%s' too long, maximum length is %llu\n"),
-                        unixpath, 
-                        sizeof(s_un.sun_path));
-          }
-        else
-          {
-            sock =  GNUNET_NETWORK_socket_create (PF_UNIX, SOCK_STREAM, 0);
-            if (sock != NULL)
-              {
-                memset (&s_un, 0, sizeof (s_un));
-                s_un.sun_family = AF_UNIX;
-                slen = strlen (unixpath) + 1;
-                if (slen >= sizeof (s_un.sun_path))
-                  slen = sizeof (s_un.sun_path) - 1;
-                memcpy (s_un.sun_path,
-                        unixpath,
-                        slen);
-                s_un.sun_path[slen] = '\0';
-                slen = sizeof (struct sockaddr_un);
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    _("UNIXPATH `%s' too long, maximum length is %llu\n"),
+                    unixpath, sizeof (s_un.sun_path));
+      }
+      else
+      {
+        sock = GNUNET_NETWORK_socket_create (PF_UNIX, SOCK_STREAM, 0);
+        if (sock != NULL)
+        {
+          memset (&s_un, 0, sizeof (s_un));
+          s_un.sun_family = AF_UNIX;
+          slen = strlen (unixpath) + 1;
+          if (slen >= sizeof (s_un.sun_path))
+            slen = sizeof (s_un.sun_path) - 1;
+          memcpy (s_un.sun_path, unixpath, slen);
+          s_un.sun_path[slen] = '\0';
+          slen = sizeof (struct sockaddr_un);
 #if LINUX
-                s_un.sun_path[0] = '\0';
+          s_un.sun_path[0] = '\0';
 #endif
 #if HAVE_SOCKADDR_IN_SIN_LEN
-                s_un.sun_len = (u_char) slen;
+          s_un.sun_len = (u_char) slen;
 #endif
-                if (GNUNET_OK !=
-                    GNUNET_NETWORK_socket_bind (sock,
-                                                (const struct sockaddr*) &s_un,
-                                                slen))
-                  {
-                    /* failed to bind => service must be running */
-                    GNUNET_free (unixpath);
-                    (void) GNUNET_NETWORK_socket_close (sock);
-                    GNUNET_SCHEDULER_add_continuation (task,
-                                                       task_cls,
-                                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-                    return;
-                  }
-                (void) GNUNET_NETWORK_socket_close (sock);
-              }
-            /* let's try IP */
-          }
+          if (GNUNET_OK !=
+              GNUNET_NETWORK_socket_bind (sock,
+                                          (const struct sockaddr *) &s_un,
+                                          slen))
+          {
+            /* failed to bind => service must be running */
+            GNUNET_free (unixpath);
+            (void) GNUNET_NETWORK_socket_close (sock);
+            GNUNET_SCHEDULER_add_continuation (task,
+                                               task_cls,
+                                               GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+            return;
+          }
+          (void) GNUNET_NETWORK_socket_close (sock);
+        }
+        /* let's try IP */
       }
+    }
     GNUNET_free_non_null (unixpath);
   }
 #endif
@@ -807,128 +791,126 @@ GNUNET_CLIENT_service_test (const char *service,
       (port > 65535) ||
       (GNUNET_OK !=
        GNUNET_CONFIGURATION_get_value_string (cfg,
-                                              service,
-                                              "HOSTNAME", &hostname)))
-    {
-      /* UNIXPATH failed (if possible) AND IP failed => error */
-      service_test_error (task, task_cls);
-      return;
-    }
-  
+                                              service, "HOSTNAME", &hostname)))
+  {
+    /* UNIXPATH failed (if possible) AND IP failed => error */
+    service_test_error (task, task_cls);
+    return;
+  }
+
   if (0 == strcmp ("localhost", hostname)
 #if WINDOWS
       && 0
 #endif
-  )
-    {
-      /* can test using 'bind' */
-      struct sockaddr_in s_in;
-      
-      memset (&s_in, 0, sizeof (s_in));
+      )
+  {
+    /* can test using 'bind' */
+    struct sockaddr_in s_in;
+
+    memset (&s_in, 0, sizeof (s_in));
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      s_in.sin_len = saddrlens[1];
+    s_in.sin_len = saddrlens[1];
 #endif
-      s_in.sin_family = AF_INET;
-      s_in.sin_port = htons (port);
+    s_in.sin_family = AF_INET;
+    s_in.sin_port = htons (port);
 
-      sock =  GNUNET_NETWORK_socket_create (AF_INET, SOCK_STREAM, 0);
-      if (sock != NULL)
-        {
-          if (GNUNET_OK !=
-              GNUNET_NETWORK_socket_bind (sock,
-                                          (const struct sockaddr*) &s_in,
-                                          sizeof (s_in)))
-            {
-              /* failed to bind => service must be running */
-              GNUNET_free (hostname);
-              (void) GNUNET_NETWORK_socket_close (sock);
-              GNUNET_SCHEDULER_add_continuation (task,
-                                                 task_cls,
-                                                 GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-              return;
-            }
-          (void) GNUNET_NETWORK_socket_close (sock);
-        }        
+    sock = GNUNET_NETWORK_socket_create (AF_INET, SOCK_STREAM, 0);
+    if (sock != NULL)
+    {
+      if (GNUNET_OK !=
+          GNUNET_NETWORK_socket_bind (sock,
+                                      (const struct sockaddr *) &s_in,
+                                      sizeof (s_in)))
+      {
+        /* failed to bind => service must be running */
+        GNUNET_free (hostname);
+        (void) GNUNET_NETWORK_socket_close (sock);
+        GNUNET_SCHEDULER_add_continuation (task,
+                                           task_cls,
+                                           GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+        return;
+      }
+      (void) GNUNET_NETWORK_socket_close (sock);
     }
+  }
 
   if (0 == strcmp ("ip6-localhost", hostname)
 #if WINDOWS
       && 0
 #endif
-  )
-    {
-      /* can test using 'bind' */
-      struct sockaddr_in6 s_in6;
-      
-      memset (&s_in6, 0, sizeof (s_in6));
+      )
+  {
+    /* can test using 'bind' */
+    struct sockaddr_in6 s_in6;
+
+    memset (&s_in6, 0, sizeof (s_in6));
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      s_in6.sin6_len = saddrlens[1];
+    s_in6.sin6_len = saddrlens[1];
 #endif
-      s_in6.sin6_family = AF_INET6;
-      s_in6.sin6_port = htons (port);
+    s_in6.sin6_family = AF_INET6;
+    s_in6.sin6_port = htons (port);
 
-      sock =  GNUNET_NETWORK_socket_create (AF_INET6, SOCK_STREAM, 0);
-      if (sock != NULL)
-        {
-          if (GNUNET_OK !=
-              GNUNET_NETWORK_socket_bind (sock,
-                                          (const struct sockaddr*) &s_in6,
-                                          sizeof (s_in6)))
-            {
-              /* failed to bind => service must be running */
-              GNUNET_free (hostname);
-              (void) GNUNET_NETWORK_socket_close (sock);
-              GNUNET_SCHEDULER_add_continuation (task,
-                                                 task_cls,
-                                                 GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-              return;
-            }
-          (void) GNUNET_NETWORK_socket_close (sock);
-        }        
+    sock = GNUNET_NETWORK_socket_create (AF_INET6, SOCK_STREAM, 0);
+    if (sock != NULL)
+    {
+      if (GNUNET_OK !=
+          GNUNET_NETWORK_socket_bind (sock,
+                                      (const struct sockaddr *) &s_in6,
+                                      sizeof (s_in6)))
+      {
+        /* failed to bind => service must be running */
+        GNUNET_free (hostname);
+        (void) GNUNET_NETWORK_socket_close (sock);
+        GNUNET_SCHEDULER_add_continuation (task,
+                                           task_cls,
+                                           GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+        return;
+      }
+      (void) GNUNET_NETWORK_socket_close (sock);
     }
+  }
 
-  if (( (0 == strcmp ("localhost", hostname)) ||
+  if (((0 == strcmp ("localhost", hostname)) ||
        (0 == strcmp ("ip6-localhost", hostname)))
 #if WINDOWS
       && 0
 #endif
-  )
-    {
-      /* all binds succeeded => claim service not running right now */
-      GNUNET_free_non_null (hostname);
-      service_test_error (task, task_cls);
-      return;
-    }   
+      )
+  {
+    /* all binds succeeded => claim service not running right now */
+    GNUNET_free_non_null (hostname);
+    service_test_error (task, task_cls);
+    return;
+  }
   GNUNET_free_non_null (hostname);
 
   /* non-localhost, try 'connect' method */
   conn = GNUNET_CLIENT_connect (service, cfg);
   if (conn == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _
-                  ("Could not connect to service `%s', must not be running.\n"),
-                  service);
-      service_test_error (task, task_cls);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _
+                ("Could not connect to service `%s', must not be running.\n"),
+                service);
+    service_test_error (task, task_cls);
+    return;
+  }
   conn->test_cb = task;
   conn->test_cb_cls = task_cls;
   conn->test_deadline = GNUNET_TIME_relative_to_absolute (timeout);
 
   if (NULL == GNUNET_CLIENT_notify_transmit_ready (conn,
-                                                   sizeof (struct GNUNET_MessageHeader),
-                                                   timeout,
-                                                   GNUNET_YES,
-                                                   &write_test, conn))  
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Failure to transmit request to service `%s'\n"),
-                  service);
-      service_test_error (task, task_cls);
-      GNUNET_CLIENT_disconnect (conn, GNUNET_NO);
-      return;
-    }
+                                                   sizeof (struct
+                                                           GNUNET_MessageHeader),
+                                                   timeout, GNUNET_YES,
+                                                   &write_test, conn))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("Failure to transmit request to service `%s'\n"), service);
+    service_test_error (task, task_cls);
+    GNUNET_CLIENT_disconnect (conn, GNUNET_NO);
+    return;
+  }
 }
 
 
@@ -953,61 +935,60 @@ static size_t client_notify (void *cls, size_t size, void *buf);
  * @param tc unused
  */
 static void
-client_delayed_retry (void *cls,
-                      const struct GNUNET_SCHEDULER_TaskContext *tc)
+client_delayed_retry (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_CLIENT_TransmitHandle *th = cls;
   struct GNUNET_TIME_Relative delay;
 
   th->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-    {
+  {
 #if DEBUG_CLIENT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Transmission failed due to shutdown.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmission failed due to shutdown.\n");
 #endif
-      th->sock->th = NULL;
-      th->notify (th->notify_cls, 0, NULL);
-      GNUNET_free (th);
-      return;
-    }
+    th->sock->th = NULL;
+    th->notify (th->notify_cls, 0, NULL);
+    GNUNET_free (th);
+    return;
+  }
   th->sock->sock = do_connect (th->sock->service_name,
-                               th->sock->cfg,
-                               th->sock->attempts++);
+                               th->sock->cfg, th->sock->attempts++);
   if (NULL == th->sock->sock)
-    {
-      /* could happen if we're out of sockets */
-      delay = GNUNET_TIME_relative_min (GNUNET_TIME_absolute_get_remaining (th->timeout), 
-                                        th->sock->back_off);
-      th->sock->back_off 
-        = GNUNET_TIME_relative_min (GNUNET_TIME_relative_multiply (th->sock->back_off, 2),
-                                    GNUNET_TIME_UNIT_SECONDS);
+  {
+    /* could happen if we're out of sockets */
+    delay =
+        GNUNET_TIME_relative_min (GNUNET_TIME_absolute_get_remaining
+                                  (th->timeout), th->sock->back_off);
+    th->sock->back_off =
+        GNUNET_TIME_relative_min (GNUNET_TIME_relative_multiply
+                                  (th->sock->back_off, 2),
+                                  GNUNET_TIME_UNIT_SECONDS);
 #if DEBUG_CLIENT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Transmission failed %u times, trying again in %llums.\n",
-                  MAX_ATTEMPTS - th->attempts_left,
-                  (unsigned long long) delay.rel_value);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmission failed %u times, trying again in %llums.\n",
+                MAX_ATTEMPTS - th->attempts_left,
+                (unsigned long long) delay.rel_value);
 #endif
-      th->reconnect_task = GNUNET_SCHEDULER_add_delayed (delay,
-                                                         &client_delayed_retry,
-                                                         th);
-      return;      
-    }
-  GNUNET_CONNECTION_ignore_shutdown (th->sock->sock,
-                                     th->sock->ignore_shutdown);
+    th->reconnect_task = GNUNET_SCHEDULER_add_delayed (delay,
+                                                       &client_delayed_retry,
+                                                       th);
+    return;
+  }
+  GNUNET_CONNECTION_ignore_shutdown (th->sock->sock, th->sock->ignore_shutdown);
   th->th = GNUNET_CONNECTION_notify_transmit_ready (th->sock->sock,
                                                     th->size,
                                                     GNUNET_TIME_absolute_get_remaining
                                                     (th->timeout),
                                                     &client_notify, th);
   if (th->th == NULL)
-    {
-      GNUNET_break (0);
-      th->sock->th = NULL;
-      th->notify (th->notify_cls, 0, NULL);
-      GNUNET_free (th);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    th->sock->th = NULL;
+    th->notify (th->notify_cls, 0, NULL);
+    GNUNET_free (th);
+    return;
+  }
 }
 
 
@@ -1030,47 +1011,49 @@ client_notify (void *cls, size_t size, void *buf)
   th->th = NULL;
   th->sock->th = NULL;
   if (buf == NULL)
+  {
+    delay = GNUNET_TIME_absolute_get_remaining (th->timeout);
+    delay.rel_value /= 2;
+    if ((0 !=
+         (GNUNET_SCHEDULER_REASON_SHUTDOWN & GNUNET_SCHEDULER_get_reason ())) ||
+        (GNUNET_YES != th->auto_retry) || (0 == --th->attempts_left) ||
+        (delay.rel_value < 1))
     {
-      delay = GNUNET_TIME_absolute_get_remaining (th->timeout);
-      delay.rel_value /= 2;
-      if ( (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & GNUNET_SCHEDULER_get_reason ())) ||
-           (GNUNET_YES != th->auto_retry) ||
-           (0 == --th->attempts_left) || 
-           (delay.rel_value < 1) )
-        {
 #if DEBUG_CLIENT
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Transmission failed %u times, giving up.\n",
-                      MAX_ATTEMPTS - th->attempts_left);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Transmission failed %u times, giving up.\n",
+                  MAX_ATTEMPTS - th->attempts_left);
 #endif
-          GNUNET_break (0 == th->notify (th->notify_cls, 0, NULL));
-          GNUNET_free (th);
-          return 0;
-        }
-      /* auto-retry */
+      GNUNET_break (0 == th->notify (th->notify_cls, 0, NULL));
+      GNUNET_free (th);
+      return 0;
+    }
+    /* auto-retry */
 #if DEBUG_CLIENT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Failed to connect to `%s', automatically trying again.\n",
-                  th->sock->service_name);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Failed to connect to `%s', automatically trying again.\n",
+                th->sock->service_name);
 #endif
-      GNUNET_CONNECTION_destroy (th->sock->sock, GNUNET_NO);
-      th->sock->sock = NULL;
-      delay = GNUNET_TIME_relative_min (delay, th->sock->back_off);
-      th->sock->back_off 
-        = GNUNET_TIME_relative_min (GNUNET_TIME_relative_multiply (th->sock->back_off, 2),
-                                    GNUNET_TIME_UNIT_SECONDS);
+    GNUNET_CONNECTION_destroy (th->sock->sock, GNUNET_NO);
+    th->sock->sock = NULL;
+    delay = GNUNET_TIME_relative_min (delay, th->sock->back_off);
+    th->sock->back_off
+        =
+        GNUNET_TIME_relative_min (GNUNET_TIME_relative_multiply
+                                  (th->sock->back_off, 2),
+                                  GNUNET_TIME_UNIT_SECONDS);
 #if DEBUG_CLIENT
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Transmission failed %u times, trying again in %llums.\n",
-                  MAX_ATTEMPTS - th->attempts_left,
-                  (unsigned long long) delay.rel_value);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmission failed %u times, trying again in %llums.\n",
+                MAX_ATTEMPTS - th->attempts_left,
+                (unsigned long long) delay.rel_value);
 #endif
-      th->sock->th = th;
-      th->reconnect_task = GNUNET_SCHEDULER_add_delayed (delay,
-                                                         &client_delayed_retry,
-                                                         th);
-      return 0;
-    }
+    th->sock->th = th;
+    th->reconnect_task = GNUNET_SCHEDULER_add_delayed (delay,
+                                                       &client_delayed_retry,
+                                                       th);
+    return 0;
+  }
   GNUNET_assert (size >= th->size);
   ret = th->notify (th->notify_cls, size, buf);
   GNUNET_free (th);
@@ -1108,12 +1091,12 @@ GNUNET_CLIENT_notify_transmit_ready (struct GNUNET_CLIENT_Connection *sock,
   struct GNUNET_CLIENT_TransmitHandle *th;
 
   if (NULL != sock->th)
-    {
-      /* If this breaks, you most likley called this function twice without waiting
-       * for completion or canceling the request */
-      GNUNET_break (0);
-      return NULL;
-    }
+  {
+    /* If this breaks, you most likley called this function twice without waiting
+     * for completion or canceling the request */
+    GNUNET_break (0);
+    return NULL;
+  }
   th = GNUNET_malloc (sizeof (struct GNUNET_CLIENT_TransmitHandle));
   th->sock = sock;
   th->size = size;
@@ -1124,26 +1107,26 @@ GNUNET_CLIENT_notify_transmit_ready (struct GNUNET_CLIENT_Connection *sock,
   th->attempts_left = MAX_ATTEMPTS;
   sock->th = th;
   if (sock->sock == NULL)
-    {
-      th->reconnect_task = GNUNET_SCHEDULER_add_delayed (sock->back_off,
-                                                         &client_delayed_retry,
-                                                         th);
-      
-    }
+  {
+    th->reconnect_task = GNUNET_SCHEDULER_add_delayed (sock->back_off,
+                                                       &client_delayed_retry,
+                                                       th);
+
+  }
   else
+  {
+    th->th = GNUNET_CONNECTION_notify_transmit_ready (sock->sock,
+                                                      size,
+                                                      timeout,
+                                                      &client_notify, th);
+    if (NULL == th->th)
     {
-      th->th = GNUNET_CONNECTION_notify_transmit_ready (sock->sock,
-                                                        size,
-                                                        timeout,
-                                                        &client_notify, th);
-      if (NULL == th->th)
-        {
-          GNUNET_break (0);
-          GNUNET_free (th);
-          sock->th = NULL;
-          return NULL;
-        }
+      GNUNET_break (0);
+      GNUNET_free (th);
+      sock->th = NULL;
+      return NULL;
     }
+  }
   return th;
 }
 
@@ -1158,16 +1141,16 @@ GNUNET_CLIENT_notify_transmit_ready_cancel (struct
                                             GNUNET_CLIENT_TransmitHandle *th)
 {
   if (th->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_assert (NULL == th->th);
-      GNUNET_SCHEDULER_cancel (th->reconnect_task);
-      th->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_assert (NULL == th->th);
+    GNUNET_SCHEDULER_cancel (th->reconnect_task);
+    th->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   else
-    {
-      GNUNET_assert (NULL != th->th);
-      GNUNET_CONNECTION_notify_transmit_ready_cancel (th->th);
-    }
+  {
+    GNUNET_assert (NULL != th->th);
+    GNUNET_CONNECTION_notify_transmit_ready_cancel (th->th);
+  }
   th->sock->th = NULL;
   GNUNET_free (th);
 }
@@ -1193,16 +1176,17 @@ transmit_for_response (void *cls, size_t size, void *buf)
   tc->sock->tag = NULL;
   msize = ntohs (tc->hdr->size);
   if (NULL == buf)
-    {
-#if DEBUG_CLIENT 
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  _("Could not submit request, not expecting to receive a response.\n"));
+  {
+#if DEBUG_CLIENT
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                _
+                ("Could not submit request, not expecting to receive a response.\n"));
 #endif
-      if (NULL != tc->rn)
-        tc->rn (tc->rn_cls, NULL);
-      GNUNET_free (tc);
-      return 0;
-    }
+    if (NULL != tc->rn)
+      tc->rn (tc->rn_cls, NULL);
+    GNUNET_free (tc);
+    return 0;
+  }
   GNUNET_assert (size >= msize);
   memcpy (buf, tc->hdr, msize);
   GNUNET_CLIENT_receive (tc->sock,
@@ -1263,13 +1247,12 @@ GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection
                                                    msize,
                                                    timeout,
                                                    auto_retry,
-                                                   &transmit_for_response,
-                                                   tc))
-    {
-      GNUNET_break (0);
-      GNUNET_free (tc);
-      return GNUNET_SYSERR;
-    }
+                                                   &transmit_for_response, tc))
+  {
+    GNUNET_break (0);
+    GNUNET_free (tc);
+    return GNUNET_SYSERR;
+  }
   sock->tag = tc;
   return GNUNET_OK;
 }