1 files changed, 549 insertions, 561 deletions

diff --git a/src/util/os_priority.c b/src/util/os_priority.c
index 4f21e7edb..a7ce0c5e5 100644
--- a/src/util/os_priority.c
+++ b/src/util/os_priority.c
@@ -59,43 +59,41 @@ static struct GNUNET_OS_Process current_process;
  */
 static void
 parent_control_handler (void *cls,
-                        const struct GNUNET_SCHEDULER_TaskContext *tc)
+                        const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_DISK_FileHandle *control_pipe =
-    (struct GNUNET_DISK_FileHandle *) cls;
+      (struct GNUNET_DISK_FileHandle *) cls;
   int sig;
 
 #if DEBUG_OS
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "`%s' invoked because of %d\n",
-       __FUNCTION__, tc->reason);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "`%s' invoked because of %d\n", __FUNCTION__,
+       tc->reason);
 #endif
   if (tc->reason &
       (GNUNET_SCHEDULER_REASON_SHUTDOWN | GNUNET_SCHEDULER_REASON_TIMEOUT |
        GNUNET_SCHEDULER_REASON_PREREQ_DONE))
+  {
+    GNUNET_DISK_npipe_close (control_pipe);
+  }
+  else
+  {
+    if (GNUNET_DISK_file_read (control_pipe, &sig, sizeof (sig)) !=
+        sizeof (sig))
     {
+      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "GNUNET_DISK_file_read");
       GNUNET_DISK_npipe_close (control_pipe);
     }
-  else
+    else
     {
-      if (GNUNET_DISK_file_read (control_pipe, &sig, sizeof (sig)) !=
-          sizeof (sig))
-        {
-          LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "GNUNET_DISK_file_read");
-          GNUNET_DISK_npipe_close (control_pipe);
-        }
-      else
-        {
 #if DEBUG_OS
-          LOG (GNUNET_ERROR_TYPE_DEBUG, "Got control code %d from parent\n",
-               sig);
+      LOG (GNUNET_ERROR_TYPE_DEBUG, "Got control code %d from parent\n", sig);
 #endif
-          GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                          control_pipe,
-                                          &parent_control_handler,
-                                          control_pipe);
-          raise (sig);
-        }
+      GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                      control_pipe, &parent_control_handler,
+                                      control_pipe);
+      raise (sig);
     }
+  }
 }
 
 
@@ -104,35 +102,34 @@ parent_control_handler (void *cls,
  */
 void
 GNUNET_OS_install_parent_control_handler (void *cls,
-                                          const struct
-                                          GNUNET_SCHEDULER_TaskContext *tc)
+                                          const struct
+                                          GNUNET_SCHEDULER_TaskContext *tc)
 {
   const char *env_buf;
   struct GNUNET_DISK_FileHandle *control_pipe;
 
   env_buf = getenv (GNUNET_OS_CONTROL_PIPE);
   if ((env_buf == NULL) || (strlen (env_buf) <= 0))
-    {
-      LOG (GNUNET_ERROR_TYPE_INFO,
-           _("Not installing a handler because $%s=%s\n"),
-           GNUNET_OS_CONTROL_PIPE, env_buf);
-      return;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_INFO, _("Not installing a handler because $%s=%s\n"),
+         GNUNET_OS_CONTROL_PIPE, env_buf);
+    return;
+  }
   control_pipe =
-    GNUNET_DISK_npipe_open (env_buf, GNUNET_DISK_OPEN_READ,
-                            GNUNET_DISK_PERM_USER_READ |
-                            GNUNET_DISK_PERM_USER_WRITE);
+      GNUNET_DISK_npipe_open (env_buf, GNUNET_DISK_OPEN_READ,
+                              GNUNET_DISK_PERM_USER_READ |
+                              GNUNET_DISK_PERM_USER_WRITE);
   if (control_pipe == NULL)
-    {
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "open", env_buf);
-      return;
-    }
+  {
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "open", env_buf);
+    return;
+  }
 #if DEBUG_OS
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Adding parent control handler pipe `%s' to the scheduler\n", env_buf);
 #endif
   GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, control_pipe,
-                                  &parent_control_handler, control_pipe);
+                                  &parent_control_handler, control_pipe);
 }
 
 
@@ -166,90 +163,90 @@ GNUNET_OS_process_kill (struct GNUNET_OS_Process *proc, int sig)
 
   ret = GNUNET_DISK_file_write (proc->control_pipe, &sig, sizeof (sig));
   if (ret != sizeof (sig))
+  {
+    if (errno == ECOMM)
     {
-      if (errno == ECOMM)
-        {
-          /* Child process is not controllable via pipe */
+      /* Child process is not controllable via pipe */
 #if DEBUG_OS
-          LOG (GNUNET_ERROR_TYPE_DEBUG,
-               "Child process is not controllable, will kill it directly\n");
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Child process is not controllable, will kill it directly\n");
 #endif
-        }
-      else if (errno == EPIPE)
-        {
+    }
+    else if (errno == EPIPE)
+    {
 #if DEBUG_OS
-          LOG (GNUNET_ERROR_TYPE_DEBUG,
-               "Failed to write into control pipe, because pipe is invalid (the child is most likely dead)\n");
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Failed to write into control pipe, because pipe is invalid (the child is most likely dead)\n");
 #endif
-        }
-      else
-        LOG (GNUNET_ERROR_TYPE_WARNING,
-             "Failed to write into control pipe , errno is %d\n", errno);
+    }
+    else
+      LOG (GNUNET_ERROR_TYPE_WARNING,
+           "Failed to write into control pipe , errno is %d\n", errno);
 #if WINDOWS && !defined(__CYGWIN__)
-      TerminateProcess (proc->handle, 0);
+    TerminateProcess (proc->handle, 0);
 #else
-      PLIBC_KILL (proc->pid, sig);
+    PLIBC_KILL (proc->pid, sig);
 #endif
-    }
+  }
   else
-    {
+  {
 #if DEBUG_OS
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Wrote control code into control pipe, now waiting\n");
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Wrote control code into control pipe, now waiting\n");
 #endif
 
 #if WINDOWS
-      /* Give it 3 seconds to die, then kill it in a nice Windows-specific way */
-      if (WaitForSingleObject (proc->handle, 3000) != WAIT_OBJECT_0)
-        TerminateProcess (proc->handle, 0);
-      res = 0;
+    /* Give it 3 seconds to die, then kill it in a nice Windows-specific way */
+    if (WaitForSingleObject (proc->handle, 3000) != WAIT_OBJECT_0)
+      TerminateProcess (proc->handle, 0);
+    res = 0;
 #else
-      struct GNUNET_NETWORK_FDSet *rfds;
-      struct GNUNET_NETWORK_FDSet *efds;
-
-      rfds = GNUNET_NETWORK_fdset_create ();
-      efds = GNUNET_NETWORK_fdset_create ();
-
-      GNUNET_NETWORK_fdset_handle_set (rfds, proc->control_pipe);
-      GNUNET_NETWORK_fdset_handle_set (efds, proc->control_pipe);
-
-      /* Ndurner thought this up, and i have no idea what it does.
-       * There's have never been any code to answer the shutdown call
-       * (write a single int into the pipe, so that this function can read it).
-       * On *nix select() will probably tell that pipe is ready
-       * for reading, once the other process shuts down,
-       * but the read () call will fail, triggering a kill ()
-       * on the pid that is already dead. This will probably result in non-0
-       * return from kill(), and therefore from this function.
-       */
-      while (1)
-        {
-          ret =
-            GNUNET_NETWORK_socket_select (rfds, NULL, efds,
-                                          GNUNET_TIME_relative_multiply
-                                          (GNUNET_TIME_relative_get_unit (),
-                                           5000));
-
-          if (ret < 1 ||
-              GNUNET_NETWORK_fdset_handle_isset (efds, proc->control_pipe))
-            {
-              /* Just to be sure */
-              PLIBC_KILL (proc->pid, sig);
-              res = 0;
-              break;
-            }
-          else
-            {
-              if (GNUNET_DISK_file_read
-                  (proc->control_pipe, &ret, sizeof (ret)) != GNUNET_OK)
-                res = PLIBC_KILL (proc->pid, sig);
-
-              /* Child signaled shutdown is in progress */
-              continue;
-            }
-        }
-#endif
+    struct GNUNET_NETWORK_FDSet *rfds;
+    struct GNUNET_NETWORK_FDSet *efds;
+
+    rfds = GNUNET_NETWORK_fdset_create ();
+    efds = GNUNET_NETWORK_fdset_create ();
+
+    GNUNET_NETWORK_fdset_handle_set (rfds, proc->control_pipe);
+    GNUNET_NETWORK_fdset_handle_set (efds, proc->control_pipe);
+
+    /* Ndurner thought this up, and i have no idea what it does.
+     * There's have never been any code to answer the shutdown call
+     * (write a single int into the pipe, so that this function can read it).
+     * On *nix select() will probably tell that pipe is ready
+     * for reading, once the other process shuts down,
+     * but the read () call will fail, triggering a kill ()
+     * on the pid that is already dead. This will probably result in non-0
+     * return from kill(), and therefore from this function.
+     */
+    while (1)
+    {
+      ret =
+          GNUNET_NETWORK_socket_select (rfds, NULL, efds,
+                                        GNUNET_TIME_relative_multiply
+                                        (GNUNET_TIME_relative_get_unit (),
+                                         5000));
+
+      if (ret < 1 ||
+          GNUNET_NETWORK_fdset_handle_isset (efds, proc->control_pipe))
+      {
+        /* Just to be sure */
+        PLIBC_KILL (proc->pid, sig);
+        res = 0;
+        break;
+      }
+      else
+      {
+        if (GNUNET_DISK_file_read (proc->control_pipe, &ret, sizeof (ret)) !=
+            GNUNET_OK)
+          res = PLIBC_KILL (proc->pid, sig);
+
+        /* Child signaled shutdown is in progress */
+        continue;
+      }
     }
+#endif
+  }
 
   return res;
 #else
@@ -324,7 +321,7 @@ ChildWaitThread (void *arg)
  */
 int
 GNUNET_OS_set_process_priority (struct GNUNET_OS_Process *proc,
-                                enum GNUNET_SCHEDULER_Priority prio)
+                                enum GNUNET_SCHEDULER_Priority prio)
 {
   int rprio;
 
@@ -334,51 +331,51 @@ GNUNET_OS_set_process_priority (struct GNUNET_OS_Process *proc,
 
   /* convert to MINGW/Unix values */
   switch (prio)
-    {
-    case GNUNET_SCHEDULER_PRIORITY_UI:
-    case GNUNET_SCHEDULER_PRIORITY_URGENT:
+  {
+  case GNUNET_SCHEDULER_PRIORITY_UI:
+  case GNUNET_SCHEDULER_PRIORITY_URGENT:
 #ifdef MINGW
-      rprio = HIGH_PRIORITY_CLASS;
+    rprio = HIGH_PRIORITY_CLASS;
 #else
-      rprio = 0;
+    rprio = 0;
 #endif
-      break;
+    break;
 
-    case GNUNET_SCHEDULER_PRIORITY_HIGH:
+  case GNUNET_SCHEDULER_PRIORITY_HIGH:
 #ifdef MINGW
-      rprio = ABOVE_NORMAL_PRIORITY_CLASS;
+    rprio = ABOVE_NORMAL_PRIORITY_CLASS;
 #else
-      rprio = 5;
+    rprio = 5;
 #endif
-      break;
+    break;
 
-    case GNUNET_SCHEDULER_PRIORITY_DEFAULT:
+  case GNUNET_SCHEDULER_PRIORITY_DEFAULT:
 #ifdef MINGW
-      rprio = NORMAL_PRIORITY_CLASS;
+    rprio = NORMAL_PRIORITY_CLASS;
 #else
-      rprio = 7;
+    rprio = 7;
 #endif
-      break;
+    break;
 
-    case GNUNET_SCHEDULER_PRIORITY_BACKGROUND:
+  case GNUNET_SCHEDULER_PRIORITY_BACKGROUND:
 #ifdef MINGW
-      rprio = BELOW_NORMAL_PRIORITY_CLASS;
+    rprio = BELOW_NORMAL_PRIORITY_CLASS;
 #else
-      rprio = 10;
+    rprio = 10;
 #endif
-      break;
+    break;
 
-    case GNUNET_SCHEDULER_PRIORITY_IDLE:
+  case GNUNET_SCHEDULER_PRIORITY_IDLE:
 #ifdef MINGW
-      rprio = IDLE_PRIORITY_CLASS;
+    rprio = IDLE_PRIORITY_CLASS;
 #else
-      rprio = 19;
+    rprio = 19;
 #endif
-      break;
-    default:
-      GNUNET_assert (0);
-      return GNUNET_SYSERR;
-    }
+    break;
+  default:
+    GNUNET_assert (0);
+    return GNUNET_SYSERR;
+  }
 
   /* Set process priority */
 #ifdef MINGW
@@ -393,27 +390,26 @@ GNUNET_OS_set_process_priority (struct GNUNET_OS_Process *proc,
 
   pid = proc->pid;
   if ((0 == pid) || (pid == getpid ()))
+  {
+    int have = nice (0);
+    int delta = rprio - have;
+
+    errno = 0;
+    if ((delta != 0) && (rprio == nice (delta)) && (errno != 0))
     {
-      int have = nice (0);
-      int delta = rprio - have;
-
-      errno = 0;
-      if ((delta != 0) && (rprio == nice (delta)) && (errno != 0))
-        {
-          LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
-                        "nice");
-          return GNUNET_SYSERR;
-        }
+      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK, "nice");
+      return GNUNET_SYSERR;
     }
+  }
   else
+  {
+    if (0 != setpriority (PRIO_PROCESS, pid, rprio))
     {
-      if (0 != setpriority (PRIO_PROCESS, pid, rprio))
-        {
-          LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
-                        "setpriority");
-          return GNUNET_SYSERR;
-        }
+      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
+                    "setpriority");
+      return GNUNET_SYSERR;
     }
+  }
 #else
 #if DEBUG_OS
   LOG (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
@@ -440,84 +436,84 @@ CreateCustomEnvTable (char **vars)
   win32_env_table = GetEnvironmentStringsA ();
   if (win32_env_table == NULL)
     return NULL;
-  for (c = 0, var_ptr = vars; *var_ptr; var_ptr += 2, c++);
+  for (c = 0, var_ptr = vars; *var_ptr; var_ptr += 2, c++) ;
   n_var = c;
   index = GNUNET_malloc (sizeof (char *) * n_var);
   for (c = 0; c < n_var; c++)
     index[c] = 0;
   for (items_count = 0, ptr = win32_env_table; ptr[0] != 0; items_count++)
+  {
+    size_t len = strlen (ptr);
+    int found = 0;
+
+    for (var_ptr = vars; *var_ptr; var_ptr++)
     {
-      size_t len = strlen (ptr);
-      int found = 0;
-
-      for (var_ptr = vars; *var_ptr; var_ptr++)
-        {
-          var = *var_ptr++;
-          val = *var_ptr;
-          var_len = strlen (var);
-          if (strncmp (var, ptr, var_len) == 0)
-            {
-              found = 1;
-              index[c] = 1;
-              tablesize += var_len + strlen (val) + 1;
-              break;
-            }
-        }
-      if (!found)
-        tablesize += len + 1;
-      ptr += len + 1;
+      var = *var_ptr++;
+      val = *var_ptr;
+      var_len = strlen (var);
+      if (strncmp (var, ptr, var_len) == 0)
+      {
+        found = 1;
+        index[c] = 1;
+        tablesize += var_len + strlen (val) + 1;
+        break;
+      }
     }
+    if (!found)
+      tablesize += len + 1;
+    ptr += len + 1;
+  }
   for (n_found = 0, c = 0, var_ptr = vars; *var_ptr; var_ptr++, c++)
+  {
+    var = *var_ptr++;
+    val = *var_ptr;
+    if (index[c] != 1)
+      n_found += strlen (var) + strlen (val) + 1;
+  }
+  result = GNUNET_malloc (tablesize + n_found + 1);
+  for (result_ptr = result, ptr = win32_env_table; ptr[0] != 0;)
+  {
+    size_t len = strlen (ptr);
+    int found = 0;
+
+    for (c = 0, var_ptr = vars; *var_ptr; var_ptr++, c++)
     {
       var = *var_ptr++;
       val = *var_ptr;
-      if (index[c] != 1)
-        n_found += strlen (var) + strlen (val) + 1;
+      var_len = strlen (var);
+      if (strncmp (var, ptr, var_len) == 0)
+      {
+        found = 1;
+        break;
+      }
     }
-  result = GNUNET_malloc (tablesize + n_found + 1);
-  for (result_ptr = result, ptr = win32_env_table; ptr[0] != 0;)
+    if (!found)
     {
-      size_t len = strlen (ptr);
-      int found = 0;
-
-      for (c = 0, var_ptr = vars; *var_ptr; var_ptr++, c++)
-        {
-          var = *var_ptr++;
-          val = *var_ptr;
-          var_len = strlen (var);
-          if (strncmp (var, ptr, var_len) == 0)
-            {
-              found = 1;
-              break;
-            }
-        }
-      if (!found)
-        {
-          strcpy (result_ptr, ptr);
-          result_ptr += len + 1;
-        }
-      else
-        {
-          strcpy (result_ptr, var);
-          result_ptr += var_len;
-          strcpy (result_ptr, val);
-          result_ptr += strlen (val) + 1;
-        }
-      ptr += len + 1;
+      strcpy (result_ptr, ptr);
+      result_ptr += len + 1;
+    }
+    else
+    {
+      strcpy (result_ptr, var);
+      result_ptr += var_len;
+      strcpy (result_ptr, val);
+      result_ptr += strlen (val) + 1;
     }
+    ptr += len + 1;
+  }
   for (c = 0, var_ptr = vars; *var_ptr; var_ptr++, c++)
+  {
+    var = *var_ptr++;
+    val = *var_ptr;
+    var_len = strlen (var);
+    if (index[c] != 1)
     {
-      var = *var_ptr++;
-      val = *var_ptr;
-      var_len = strlen (var);
-      if (index[c] != 1)
-        {
-          strcpy (result_ptr, var);
-          result_ptr += var_len;
-          strcpy (result_ptr, val);
-          result_ptr += strlen (val) + 1;
-        }
+      strcpy (result_ptr, var);
+      result_ptr += var_len;
+      strcpy (result_ptr, val);
+      result_ptr += strlen (val) + 1;
     }
+  }
   FreeEnvironmentStrings (win32_env_table);
   GNUNET_free (index);
   *result_ptr = 0;
@@ -537,8 +533,8 @@ CreateCustomEnvTable (char **vars)
  */
 struct GNUNET_OS_Process *
 GNUNET_OS_start_process_va (struct GNUNET_DISK_PipeHandle *pipe_stdin,
-                            struct GNUNET_DISK_PipeHandle *pipe_stdout,
-                            const char *filename, va_list va)
+                            struct GNUNET_DISK_PipeHandle *pipe_stdout,
+                            const char *filename, va_list va)
 {
   va_list ap;
 
@@ -559,9 +555,9 @@ GNUNET_OS_start_process_va (struct GNUNET_DISK_PipeHandle *pipe_stdin,
 
 #if ENABLE_WINDOWS_WORKAROUNDS
   control_pipe =
-    GNUNET_DISK_npipe_create (&childpipename, GNUNET_DISK_OPEN_WRITE,
-                              GNUNET_DISK_PERM_USER_READ |
-                              GNUNET_DISK_PERM_USER_WRITE);
+      GNUNET_DISK_npipe_create (&childpipename, GNUNET_DISK_OPEN_WRITE,
+                                GNUNET_DISK_PERM_USER_READ |
+                                GNUNET_DISK_PERM_USER_WRITE);
   if (control_pipe == NULL)
     return NULL;
 #endif
@@ -569,38 +565,35 @@ GNUNET_OS_start_process_va (struct GNUNET_DISK_PipeHandle *pipe_stdin,
   argc = 0;
   va_copy (ap, va);
   while (NULL != va_arg (ap, char *))
-      argc++;
+         argc++;
 
   va_end (ap);
   argv = GNUNET_malloc (sizeof (char *) * (argc + 1));
   argc = 0;
   va_copy (ap, va);
   while (NULL != (argv[argc] = va_arg (ap, char *)))
-      argc++;
+         argc++;
 
   va_end (ap);
   if (pipe_stdout != NULL)
-    {
-      GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
-                                         (pipe_stdout,
-                                          GNUNET_DISK_PIPE_END_WRITE),
-                                         &fd_stdout_write, sizeof (int));
-      GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
-                                         (pipe_stdout,
-                                          GNUNET_DISK_PIPE_END_READ),
-                                         &fd_stdout_read, sizeof (int));
-    }
+  {
+    GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
+                                       (pipe_stdout,
+                                        GNUNET_DISK_PIPE_END_WRITE),
+                                       &fd_stdout_write, sizeof (int));
+    GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
+                                       (pipe_stdout, GNUNET_DISK_PIPE_END_READ),
+                                       &fd_stdout_read, sizeof (int));
+  }
   if (pipe_stdin != NULL)
-    {
-      GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
-                                         (pipe_stdin,
-                                          GNUNET_DISK_PIPE_END_READ),
-                                         &fd_stdin_read, sizeof (int));
-      GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
-                                         (pipe_stdin,
-                                          GNUNET_DISK_PIPE_END_WRITE),
-                                         &fd_stdin_write, sizeof (int));
-    }
+  {
+    GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
+                                       (pipe_stdin, GNUNET_DISK_PIPE_END_READ),
+                                       &fd_stdin_read, sizeof (int));
+    GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
+                                       (pipe_stdin, GNUNET_DISK_PIPE_END_WRITE),
+                                       &fd_stdin_write, sizeof (int));
+  }
 
 #if HAVE_WORKING_VFORK
   ret = vfork ();
@@ -608,46 +601,44 @@ GNUNET_OS_start_process_va (struct GNUNET_DISK_PipeHandle *pipe_stdin,
   ret = fork ();
 #endif
   if (ret != 0)
+  {
+    if (ret == -1)
     {
-      if (ret == -1)
-        {
-          LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "fork");
+      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "fork");
 #if ENABLE_WINDOWS_WORKAROUNDS
-          GNUNET_DISK_npipe_close (control_pipe);
+      GNUNET_DISK_npipe_close (control_pipe);
 #endif
-        }
-      else
-        {
+    }
+    else
+    {
 
 #if HAVE_WORKING_VFORK
-          /* let's hope vfork actually works; for some extreme cases (including
-           * a testcase) we need 'execvp' to have run before we return, since
-           * we may send a signal to the process next and we don't want it
-           * to be caught by OUR signal handler (but either by the default
-           * handler or the actual handler as installed by the process itself). */
+      /* let's hope vfork actually works; for some extreme cases (including
+       * a testcase) we need 'execvp' to have run before we return, since
+       * we may send a signal to the process next and we don't want it
+       * to be caught by OUR signal handler (but either by the default
+       * handler or the actual handler as installed by the process itself). */
 #else
-          /* let's give the child process a chance to run execvp, 1s should
-           * be plenty in practice */
-          if (pipe_stdout != NULL)
-            GNUNET_DISK_pipe_close_end (pipe_stdout,
-                                        GNUNET_DISK_PIPE_END_WRITE);
-          if (pipe_stdin != NULL)
-            GNUNET_DISK_pipe_close_end (pipe_stdin,
-                                        GNUNET_DISK_PIPE_END_READ);
-          sleep (1);
+      /* let's give the child process a chance to run execvp, 1s should
+       * be plenty in practice */
+      if (pipe_stdout != NULL)
+        GNUNET_DISK_pipe_close_end (pipe_stdout, GNUNET_DISK_PIPE_END_WRITE);
+      if (pipe_stdin != NULL)
+        GNUNET_DISK_pipe_close_end (pipe_stdin, GNUNET_DISK_PIPE_END_READ);
+      sleep (1);
 #endif
-          gnunet_proc = GNUNET_malloc (sizeof (struct GNUNET_OS_Process));
-          gnunet_proc->pid = ret;
+      gnunet_proc = GNUNET_malloc (sizeof (struct GNUNET_OS_Process));
+      gnunet_proc->pid = ret;
 #if ENABLE_WINDOWS_WORKAROUNDS
-          gnunet_proc->control_pipe = control_pipe;
+      gnunet_proc->control_pipe = control_pipe;
 #endif
-        }
-      GNUNET_free (argv);
+    }
+    GNUNET_free (argv);
 #if ENABLE_WINDOWS_WORKAROUNDS
-      GNUNET_free (childpipename);
+    GNUNET_free (childpipename);
 #endif
-      return gnunet_proc;
-    }
+    return gnunet_proc;
+  }
 
 #if ENABLE_WINDOWS_WORKAROUNDS
   setenv (GNUNET_OS_CONTROL_PIPE, childpipename, 1);
@@ -655,21 +646,21 @@ GNUNET_OS_start_process_va (struct GNUNET_DISK_PipeHandle *pipe_stdin,
 #endif
 
   if (pipe_stdout != NULL)
-    {
-      GNUNET_break (0 == close (fd_stdout_read));
-      if (-1 == dup2 (fd_stdout_write, 1))
-        LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2");
-      GNUNET_break (0 == close (fd_stdout_write));
-    }
+  {
+    GNUNET_break (0 == close (fd_stdout_read));
+    if (-1 == dup2 (fd_stdout_write, 1))
+      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2");
+    GNUNET_break (0 == close (fd_stdout_write));
+  }
 
   if (pipe_stdin != NULL)
-    {
+  {
 
-      GNUNET_break (0 == close (fd_stdin_write));
-      if (-1 == dup2 (fd_stdin_read, 0))
-        LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2");
-      GNUNET_break (0 == close (fd_stdin_read));
-    }
+    GNUNET_break (0 == close (fd_stdin_write));
+    if (-1 == dup2 (fd_stdin_read, 0))
+      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2");
+    GNUNET_break (0 == close (fd_stdin_read));
+  }
   execvp (filename, argv);
   LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
   _exit (1);
@@ -705,8 +696,8 @@ GNUNET_OS_start_process_va (struct GNUNET_DISK_PipeHandle *pipe_stdin,
   pathbuf_len = GetEnvironmentVariableA ("PATH", (char *) &pathbuf, 0);
 
   alloc_len =
-    pathbuf_len + 1 + strlen (self_prefix) + 1 + strlen (bindir) + 1 +
-    strlen (libdir);
+      pathbuf_len + 1 + strlen (self_prefix) + 1 + strlen (bindir) + 1 +
+      strlen (libdir);
 
   pathbuf = GNUNET_malloc (alloc_len * sizeof (char));
 
@@ -729,39 +720,39 @@ GNUNET_OS_start_process_va (struct GNUNET_DISK_PipeHandle *pipe_stdin,
   if (non_const_filename[1] == ':')
     snprintf (path, sizeof (path) / sizeof (char), "%s", non_const_filename);
   else if (!SearchPathA
-           (pathbuf, non_const_filename, NULL, sizeof (path) / sizeof (char),
-            path, NULL))
-    {
-      SetErrnoFromWinError (GetLastError ());
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "SearchPath",
-                         non_const_filename);
-      GNUNET_free (non_const_filename);
-      GNUNET_free (pathbuf);
-      return NULL;
-    }
+           (pathbuf, non_const_filename, NULL, sizeof (path) / sizeof (char),
+            path, NULL))
+  {
+    SetErrnoFromWinError (GetLastError ());
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "SearchPath",
+                       non_const_filename);
+    GNUNET_free (non_const_filename);
+    GNUNET_free (pathbuf);
+    return NULL;
+  }
   GNUNET_free (pathbuf);
   GNUNET_free (non_const_filename);
 
   cmdlen = 0;
   va_copy (ap, va);
   while (NULL != (arg = va_arg (ap, char *)))
-    {
-      if (cmdlen == 0)
-        cmdlen = cmdlen + strlen (path) + 3;
-      else
-        cmdlen = cmdlen + strlen (arg) + 3;
-    }
+  {
+    if (cmdlen == 0)
+      cmdlen = cmdlen + strlen (path) + 3;
+    else
+      cmdlen = cmdlen + strlen (arg) + 3;
+  }
   va_end (ap);
 
   cmd = idx = GNUNET_malloc (sizeof (char) * (cmdlen + 1));
   va_copy (ap, va);
   while (NULL != (arg = va_arg (ap, char *)))
-    {
-      if (idx == cmd)
-        idx += sprintf (idx, "\"%s\" ", path);
-      else
-        idx += sprintf (idx, "\"%s\" ", arg);
-    }
+  {
+    if (idx == cmd)
+      idx += sprintf (idx, "\"%s\" ", path);
+    else
+      idx += sprintf (idx, "\"%s\" ", arg);
+  }
   va_end (ap);
 
   memset (&start, 0, sizeof (start));
@@ -771,37 +762,36 @@ GNUNET_OS_start_process_va (struct GNUNET_DISK_PipeHandle *pipe_stdin,
     start.dwFlags |= STARTF_USESTDHANDLES;
 
   if (pipe_stdin != NULL)
-    {
-      GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
-                                         (pipe_stdin,
-                                          GNUNET_DISK_PIPE_END_READ),
-                                         &stdin_handle, sizeof (HANDLE));
-      start.hStdInput = stdin_handle;
-    }
+  {
+    GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
+                                       (pipe_stdin, GNUNET_DISK_PIPE_END_READ),
+                                       &stdin_handle, sizeof (HANDLE));
+    start.hStdInput = stdin_handle;
+  }
 
   if (pipe_stdout != NULL)
-    {
-      GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
-                                         (pipe_stdout,
-                                          GNUNET_DISK_PIPE_END_WRITE),
-                                         &stdout_handle, sizeof (HANDLE));
-      start.hStdOutput = stdout_handle;
-    }
+  {
+    GNUNET_DISK_internal_file_handle_ (GNUNET_DISK_pipe_handle
+                                       (pipe_stdout,
+                                        GNUNET_DISK_PIPE_END_WRITE),
+                                       &stdout_handle, sizeof (HANDLE));
+    start.hStdOutput = stdout_handle;
+  }
 
   control_pipe =
-    GNUNET_DISK_npipe_create (&childpipename, GNUNET_DISK_OPEN_WRITE,
-                              GNUNET_DISK_PERM_USER_READ |
-                              GNUNET_DISK_PERM_USER_WRITE);
+      GNUNET_DISK_npipe_create (&childpipename, GNUNET_DISK_OPEN_WRITE,
+                                GNUNET_DISK_PERM_USER_READ |
+                                GNUNET_DISK_PERM_USER_WRITE);
   if (control_pipe == NULL)
-    {
-      GNUNET_free (cmd);
-      GNUNET_free (path);
-      return NULL;
-    }
+  {
+    GNUNET_free (cmd);
+    GNUNET_free (path);
+    return NULL;
+  }
 
 #if DEBUG_OS
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Opened the parent end of the pipe `%s'\n", childpipename);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Opened the parent end of the pipe `%s'\n",
+       childpipename);
 #endif
 
   GNUNET_asprintf (&our_env[0], "%s=", GNUNET_OS_CONTROL_PIPE);
@@ -814,13 +804,13 @@ GNUNET_OS_start_process_va (struct GNUNET_DISK_PipeHandle *pipe_stdin,
   if (!CreateProcessA
       (path, cmd, NULL, NULL, TRUE, DETACHED_PROCESS | CREATE_SUSPENDED,
        env_block, NULL, &start, &proc))
-    {
-      SetErrnoFromWinError (GetLastError ());
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "CreateProcess", path);
-      GNUNET_free (env_block);
-      GNUNET_free (cmd);
-      return NULL;
-    }
+  {
+    SetErrnoFromWinError (GetLastError ());
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "CreateProcess", path);
+    GNUNET_free (env_block);
+    GNUNET_free (cmd);
+    return NULL;
+  }
 
   GNUNET_free (env_block);
 
@@ -854,8 +844,8 @@ GNUNET_OS_start_process_va (struct GNUNET_DISK_PipeHandle *pipe_stdin,
  */
 struct GNUNET_OS_Process *
 GNUNET_OS_start_process (struct GNUNET_DISK_PipeHandle *pipe_stdin,
-                         struct GNUNET_DISK_PipeHandle *pipe_stdout,
-                         const char *filename, ...)
+                         struct GNUNET_DISK_PipeHandle *pipe_stdout,
+                         const char *filename, ...)
 {
   struct GNUNET_OS_Process *ret;
   va_list ap;
@@ -878,7 +868,7 @@ GNUNET_OS_start_process (struct GNUNET_DISK_PipeHandle *pipe_stdin,
  */
 struct GNUNET_OS_Process *
 GNUNET_OS_start_process_v (const int *lsocks, const char *filename,
-                           char *const argv[])
+                           char *const argv[])
 {
 #if ENABLE_WINDOWS_WORKAROUNDS
   struct GNUNET_DISK_FileHandle *control_pipe = NULL;
@@ -900,9 +890,9 @@ GNUNET_OS_start_process_v (const int *lsocks, const char *filename,
 
 #if ENABLE_WINDOWS_WORKAROUNDS
   control_pipe =
-    GNUNET_DISK_npipe_create (&childpipename, GNUNET_DISK_OPEN_WRITE,
-                              GNUNET_DISK_PERM_USER_READ |
-                              GNUNET_DISK_PERM_USER_WRITE);
+      GNUNET_DISK_npipe_create (&childpipename, GNUNET_DISK_OPEN_WRITE,
+                                GNUNET_DISK_PERM_USER_READ |
+                                GNUNET_DISK_PERM_USER_WRITE);
   if (control_pipe == NULL)
     return NULL;
 #endif
@@ -910,52 +900,52 @@ GNUNET_OS_start_process_v (const int *lsocks, const char *filename,
   lscp = NULL;
   ls = 0;
   if (lsocks != NULL)
-    {
-      i = 0;
-      while (-1 != (k = lsocks[i++]))
-        GNUNET_array_append (lscp, ls, k);
-      GNUNET_array_append (lscp, ls, -1);
-    }
+  {
+    i = 0;
+    while (-1 != (k = lsocks[i++]))
+      GNUNET_array_append (lscp, ls, k);
+    GNUNET_array_append (lscp, ls, -1);
+  }
 #if HAVE_WORKING_VFORK
   ret = vfork ();
 #else
   ret = fork ();
 #endif
   if (ret != 0)
+  {
+    if (ret == -1)
     {
-      if (ret == -1)
-        {
-          LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "fork");
+      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "fork");
 #if ENABLE_WINDOWS_WORKAROUNDS
-          GNUNET_DISK_npipe_close (control_pipe);
+      GNUNET_DISK_npipe_close (control_pipe);
 #endif
-        }
-      else
-        {
+    }
+    else
+    {
 #if HAVE_WORKING_VFORK
-          /* let's hope vfork actually works; for some extreme cases (including
-           * a testcase) we need 'execvp' to have run before we return, since
-           * we may send a signal to the process next and we don't want it
-           * to be caught by OUR signal handler (but either by the default
-           * handler or the actual handler as installed by the process itself). */
+      /* let's hope vfork actually works; for some extreme cases (including
+       * a testcase) we need 'execvp' to have run before we return, since
+       * we may send a signal to the process next and we don't want it
+       * to be caught by OUR signal handler (but either by the default
+       * handler or the actual handler as installed by the process itself). */
 #else
-          /* let's give the child process a chance to run execvp, 1s should
-           * be plenty in practice */
-          sleep (1);
+      /* let's give the child process a chance to run execvp, 1s should
+       * be plenty in practice */
+      sleep (1);
 #endif
-          gnunet_proc = GNUNET_malloc (sizeof (struct GNUNET_OS_Process));
-          gnunet_proc->pid = ret;
+      gnunet_proc = GNUNET_malloc (sizeof (struct GNUNET_OS_Process));
+      gnunet_proc->pid = ret;
 #if ENABLE_WINDOWS_WORKAROUNDS
-          gnunet_proc->control_pipe = control_pipe;
+      gnunet_proc->control_pipe = control_pipe;
 
 #endif
-        }
-      GNUNET_array_grow (lscp, ls, 0);
+    }
+    GNUNET_array_grow (lscp, ls, 0);
 #if ENABLE_WINDOWS_WORKAROUNDS
-      GNUNET_free (childpipename);
+    GNUNET_free (childpipename);
 #endif
-      return gnunet_proc;
-    }
+    return gnunet_proc;
+  }
 
 #if ENABLE_WINDOWS_WORKAROUNDS
   setenv (GNUNET_OS_CONTROL_PIPE, childpipename, 1);
@@ -963,47 +953,47 @@ GNUNET_OS_start_process_v (const int *lsocks, const char *filename,
 #endif
 
   if (lscp != NULL)
+  {
+    /* read systemd documentation... */
+    GNUNET_snprintf (lpid, sizeof (lpid), "%u", getpid ());
+    setenv ("LISTEN_PID", lpid, 1);
+    i = 0;
+    tgt = 3;
+    while (-1 != lscp[i])
     {
-      /* read systemd documentation... */
-      GNUNET_snprintf (lpid, sizeof (lpid), "%u", getpid ());
-      setenv ("LISTEN_PID", lpid, 1);
-      i = 0;
-      tgt = 3;
-      while (-1 != lscp[i])
-        {
-          j = i + 1;
-          while (-1 != lscp[j])
-            {
-              if (lscp[j] == tgt)
-                {
-                  /* dup away */
-                  k = dup (lscp[j]);
-                  GNUNET_assert (-1 != k);
-                  GNUNET_assert (0 == close (lscp[j]));
-                  lscp[j] = k;
-                  break;
-                }
-              j++;
-            }
-          if (lscp[i] != tgt)
-            {
-              /* Bury any existing FD, no matter what; they should all be closed
-               * on exec anyway and the important onces have been dup'ed away */
-              (void) close (tgt);
-              GNUNET_assert (-1 != dup2 (lscp[i], tgt));
-            }
-          /* unset close-on-exec flag */
-          flags = fcntl (tgt, F_GETFD);
-          GNUNET_assert (flags >= 0);
-          flags &= ~FD_CLOEXEC;
-          fflush (stderr);
-          (void) fcntl (tgt, F_SETFD, flags);
-          tgt++;
-          i++;
-        }
-      GNUNET_snprintf (fds, sizeof (fds), "%u", i);
-      setenv ("LISTEN_FDS", fds, 1);
+      j = i + 1;
+      while (-1 != lscp[j])
+      {
+        if (lscp[j] == tgt)
+        {
+          /* dup away */
+          k = dup (lscp[j]);
+          GNUNET_assert (-1 != k);
+          GNUNET_assert (0 == close (lscp[j]));
+          lscp[j] = k;
+          break;
+        }
+        j++;
+      }
+      if (lscp[i] != tgt)
+      {
+        /* Bury any existing FD, no matter what; they should all be closed
+         * on exec anyway and the important onces have been dup'ed away */
+        (void) close (tgt);
+        GNUNET_assert (-1 != dup2 (lscp[i], tgt));
+      }
+      /* unset close-on-exec flag */
+      flags = fcntl (tgt, F_GETFD);
+      GNUNET_assert (flags >= 0);
+      flags &= ~FD_CLOEXEC;
+      fflush (stderr);
+      (void) fcntl (tgt, F_SETFD, flags);
+      tgt++;
+      i++;
     }
+    GNUNET_snprintf (fds, sizeof (fds), "%u", i);
+    setenv ("LISTEN_FDS", fds, 1);
+  }
   GNUNET_array_grow (lscp, ls, 0);
   execvp (filename, argv);
   LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
@@ -1041,8 +1031,8 @@ GNUNET_OS_start_process_v (const int *lsocks, const char *filename,
   pathbuf_len = GetEnvironmentVariableA ("PATH", (char *) &pathbuf, 0);
 
   alloc_len =
-    pathbuf_len + 1 + strlen (self_prefix) + 1 + strlen (bindir) + 1 +
-    strlen (libdir);
+      pathbuf_len + 1 + strlen (self_prefix) + 1 + strlen (bindir) + 1 +
+      strlen (libdir);
 
   pathbuf = GNUNET_malloc (alloc_len * sizeof (char));
 
@@ -1054,11 +1044,11 @@ GNUNET_OS_start_process_v (const int *lsocks, const char *filename,
 
   alloc_len = GetEnvironmentVariableA ("PATH", ptr, pathbuf_len);
   if (alloc_len != pathbuf_len - 1)
-    {
-      GNUNET_free (pathbuf);
-      errno = ENOSYS;           /* PATH changed on the fly. What kind of error is that? */
-      return NULL;
-    }
+  {
+    GNUNET_free (pathbuf);
+    errno = ENOSYS;             /* PATH changed on the fly. What kind of error is that? */
+    return NULL;
+  }
 
   cmdlen = strlen (filename);
   if (cmdlen < 5 || strcmp (&filename[cmdlen - 4], ".exe") != 0)
@@ -1070,26 +1060,26 @@ GNUNET_OS_start_process_v (const int *lsocks, const char *filename,
   if (non_const_filename[1] == ':')
     snprintf (path, sizeof (path) / sizeof (char), "%s", non_const_filename);
   else if (!SearchPathA
-           (pathbuf, non_const_filename, NULL, sizeof (path) / sizeof (char),
-            path, NULL))
-    {
-      SetErrnoFromWinError (GetLastError ());
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "SearchPath",
-                         non_const_filename);
-      GNUNET_free (non_const_filename);
-      GNUNET_free (pathbuf);
-      return NULL;
-    }
+           (pathbuf, non_const_filename, NULL, sizeof (path) / sizeof (char),
+            path, NULL))
+  {
+    SetErrnoFromWinError (GetLastError ());
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "SearchPath",
+                       non_const_filename);
+    GNUNET_free (non_const_filename);
+    GNUNET_free (pathbuf);
+    return NULL;
+  }
   GNUNET_free (pathbuf);
   GNUNET_free (non_const_filename);
 
   /* Count the number of arguments */
   arg = (char **) argv;
   while (*arg)
-    {
-      arg++;
-      argcount++;
-    }
+  {
+    arg++;
+    argcount++;
+  }
 
   /* Allocate a copy argv */
   non_const_argv = GNUNET_malloc (sizeof (char *) * (argcount + 1));
@@ -1098,33 +1088,33 @@ GNUNET_OS_start_process_v (const int *lsocks, const char *filename,
   argcount = 0;
   arg = (char **) argv;
   while (*arg)
-    {
-      if (arg == argv)
-        non_const_argv[argcount] = GNUNET_strdup (path);
-      else
-        non_const_argv[argcount] = GNUNET_strdup (*arg);
-      arg++;
-      argcount++;
-    }
+  {
+    if (arg == argv)
+      non_const_argv[argcount] = GNUNET_strdup (path);
+    else
+      non_const_argv[argcount] = GNUNET_strdup (*arg);
+    arg++;
+    argcount++;
+  }
   non_const_argv[argcount] = NULL;
 
   /* Count cmd len */
   cmdlen = 1;
   arg = non_const_argv;
   while (*arg)
-    {
-      cmdlen = cmdlen + strlen (*arg) + 3;
-      arg++;
-    }
+  {
+    cmdlen = cmdlen + strlen (*arg) + 3;
+    arg++;
+  }
 
   /* Allocate and create cmd */
   cmd = idx = GNUNET_malloc (sizeof (char) * cmdlen);
   arg = non_const_argv;
   while (*arg)
-    {
-      idx += sprintf (idx, "\"%s\" ", *arg);
-      arg++;
-    }
+  {
+    idx += sprintf (idx, "\"%s\" ", *arg);
+    arg++;
+  }
 
   while (argcount > 0)
     GNUNET_free (non_const_argv[--argcount]);
@@ -1134,19 +1124,19 @@ GNUNET_OS_start_process_v (const int *lsocks, const char *filename,
   start.cb = sizeof (start);
 
   control_pipe =
-    GNUNET_DISK_npipe_create (&childpipename, GNUNET_DISK_OPEN_WRITE,
-                              GNUNET_DISK_PERM_USER_READ |
-                              GNUNET_DISK_PERM_USER_WRITE);
+      GNUNET_DISK_npipe_create (&childpipename, GNUNET_DISK_OPEN_WRITE,
+                                GNUNET_DISK_PERM_USER_READ |
+                                GNUNET_DISK_PERM_USER_WRITE);
   if (control_pipe == NULL)
-    {
-      GNUNET_free (cmd);
-      GNUNET_free (path);
-      return NULL;
-    }
+  {
+    GNUNET_free (cmd);
+    GNUNET_free (path);
+    return NULL;
+  }
 
 #if DEBUG_OS
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Opened the parent end of the pipe `%s'\n", childpipename);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Opened the parent end of the pipe `%s'\n",
+       childpipename);
 #endif
 
   GNUNET_asprintf (&our_env[0], "%s=", GNUNET_OS_CONTROL_PIPE);
@@ -1159,13 +1149,13 @@ GNUNET_OS_start_process_v (const int *lsocks, const char *filename,
   if (!CreateProcess
       (path, cmd, NULL, NULL, FALSE, DETACHED_PROCESS | CREATE_SUSPENDED,
        env_block, NULL, &start, &proc))
-    {
-      SetErrnoFromWinError (GetLastError ());
-      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "CreateProcess");
-      GNUNET_free (env_block);
-      GNUNET_free (cmd);
-      return NULL;
-    }
+  {
+    SetErrnoFromWinError (GetLastError ());
+    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "CreateProcess");
+    GNUNET_free (env_block);
+    GNUNET_free (cmd);
+    return NULL;
+  }
 
   GNUNET_free (env_block);
 
@@ -1194,8 +1184,8 @@ GNUNET_OS_start_process_v (const int *lsocks, const char *filename,
  */
 int
 GNUNET_OS_process_status (struct GNUNET_OS_Process *proc,
-                          enum GNUNET_OS_ProcessStatusType *type,
-                          unsigned long *code)
+                          enum GNUNET_OS_ProcessStatusType *type,
+                          unsigned long *code)
 {
 #ifndef MINGW
   int status;
@@ -1204,48 +1194,48 @@ GNUNET_OS_process_status (struct GNUNET_OS_Process *proc,
   GNUNET_assert (0 != proc);
   ret = waitpid (proc->pid, &status, WNOHANG);
   if (ret < 0)
-    {
-      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-      return GNUNET_SYSERR;
-    }
+  {
+    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+    return GNUNET_SYSERR;
+  }
   if (0 == ret)
-    {
-      *type = GNUNET_OS_PROCESS_RUNNING;
-      *code = 0;
-      return GNUNET_NO;
-    }
+  {
+    *type = GNUNET_OS_PROCESS_RUNNING;
+    *code = 0;
+    return GNUNET_NO;
+  }
   if (proc->pid != ret)
-    {
-      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-      return GNUNET_SYSERR;
-    }
+  {
+    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+    return GNUNET_SYSERR;
+  }
   if (WIFEXITED (status))
-    {
-      *type = GNUNET_OS_PROCESS_EXITED;
-      *code = WEXITSTATUS (status);
-    }
+  {
+    *type = GNUNET_OS_PROCESS_EXITED;
+    *code = WEXITSTATUS (status);
+  }
   else if (WIFSIGNALED (status))
-    {
-      *type = GNUNET_OS_PROCESS_SIGNALED;
-      *code = WTERMSIG (status);
-    }
+  {
+    *type = GNUNET_OS_PROCESS_SIGNALED;
+    *code = WTERMSIG (status);
+  }
   else if (WIFSTOPPED (status))
-    {
-      *type = GNUNET_OS_PROCESS_SIGNALED;
-      *code = WSTOPSIG (status);
-    }
+  {
+    *type = GNUNET_OS_PROCESS_SIGNALED;
+    *code = WSTOPSIG (status);
+  }
 #ifdef WIFCONTINUED
   else if (WIFCONTINUED (status))
-    {
-      *type = GNUNET_OS_PROCESS_RUNNING;
-      *code = 0;
-    }
+  {
+    *type = GNUNET_OS_PROCESS_RUNNING;
+    *code = 0;
+  }
 #endif
   else
-    {
-      *type = GNUNET_OS_PROCESS_UNKNOWN;
-      *code = 0;
-    }
+  {
+    *type = GNUNET_OS_PROCESS_UNKNOWN;
+    *code = 0;
+  }
 #else
   HANDLE h;
   DWORD c, error_code, ret;
@@ -1253,11 +1243,11 @@ GNUNET_OS_process_status (struct GNUNET_OS_Process *proc,
   h = proc->handle;
   ret = proc->pid;
   if (h == NULL || ret == 0)
-    {
-      LOG (GNUNET_ERROR_TYPE_WARNING,
-           "Invalid process information {%d, %08X}\n", ret, h);
-      return GNUNET_SYSERR;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING, "Invalid process information {%d, %08X}\n",
+         ret, h);
+    return GNUNET_SYSERR;
+  }
   if (h == NULL)
     h = GetCurrentProcess ();
 
@@ -1265,17 +1255,17 @@ GNUNET_OS_process_status (struct GNUNET_OS_Process *proc,
   ret = GetExitCodeProcess (h, &c);
   error_code = GetLastError ();
   if (ret == 0 || error_code != NO_ERROR)
-    {
-      SetErrnoFromWinError (error_code);
-      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "GetExitCodeProcess");
-      return GNUNET_SYSERR;
-    }
+  {
+    SetErrnoFromWinError (error_code);
+    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "GetExitCodeProcess");
+    return GNUNET_SYSERR;
+  }
   if (STILL_ACTIVE == c)
-    {
-      *type = GNUNET_OS_PROCESS_RUNNING;
-      *code = 0;
-      return GNUNET_NO;
-    }
+  {
+    *type = GNUNET_OS_PROCESS_RUNNING;
+    *code = 0;
+    return GNUNET_NO;
+  }
   *type = GNUNET_OS_PROCESS_EXITED;
   *code = c;
 #endif
@@ -1305,19 +1295,19 @@ GNUNET_OS_process_wait (struct GNUNET_OS_Process *proc)
 
   h = proc->handle;
   if (NULL == h)
-    {
-      LOG (GNUNET_ERROR_TYPE_WARNING,
-           "Invalid process information {%d, %08X}\n", proc->pid, h);
-      return GNUNET_SYSERR;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING, "Invalid process information {%d, %08X}\n",
+         proc->pid, h);
+    return GNUNET_SYSERR;
+  }
   if (h == NULL)
     h = GetCurrentProcess ();
 
   if (WAIT_OBJECT_0 != WaitForSingleObject (h, INFINITE))
-    {
-      SetErrnoFromWinError (GetLastError ());
-      ret = GNUNET_SYSERR;
-    }
+  {
+    SetErrnoFromWinError (GetLastError ());
+    ret = GNUNET_SYSERR;
+  }
   else
     ret = GNUNET_OK;
 
@@ -1391,10 +1381,10 @@ GNUNET_OS_command_stop (struct GNUNET_OS_CommandHandle *cmd)
 {
 
   if (cmd->proc != NULL)
-    {
-      GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != cmd->rtask);
-      GNUNET_SCHEDULER_cancel (cmd->rtask);
-    }
+  {
+    GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != cmd->rtask);
+    GNUNET_SCHEDULER_cancel (cmd->rtask);
+  }
   (void) GNUNET_OS_process_kill (cmd->eip, SIGKILL);
   GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (cmd->eip));
   GNUNET_OS_process_close (cmd->eip);
@@ -1418,43 +1408,42 @@ cmd_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   ssize_t ret;
 
   cmd->rtask = GNUNET_SCHEDULER_NO_TASK;
-  if (GNUNET_YES !=
-      GNUNET_NETWORK_fdset_handle_isset (tc->read_ready, cmd->r))
-    {
-      /* timeout, shutdown, etc. */
-      proc = cmd->proc;
-      cmd->proc = NULL;
-      proc (cmd->proc_cls, NULL);
-      return;
-    }
+  if (GNUNET_YES != GNUNET_NETWORK_fdset_handle_isset (tc->read_ready, cmd->r))
+  {
+    /* timeout, shutdown, etc. */
+    proc = cmd->proc;
+    cmd->proc = NULL;
+    proc (cmd->proc_cls, NULL);
+    return;
+  }
   ret =
-    GNUNET_DISK_file_read (cmd->r, &cmd->buf[cmd->off],
-                           sizeof (cmd->buf) - cmd->off);
+      GNUNET_DISK_file_read (cmd->r, &cmd->buf[cmd->off],
+                             sizeof (cmd->buf) - cmd->off);
   if (ret <= 0)
+  {
+    if ((cmd->off > 0) && (cmd->off < sizeof (cmd->buf)))
     {
-      if ((cmd->off > 0) && (cmd->off < sizeof (cmd->buf)))
-        {
-          cmd->buf[cmd->off] = '\0';
-          cmd->proc (cmd->proc_cls, cmd->buf);
-        }
-      proc = cmd->proc;
-      cmd->proc = NULL;
-      proc (cmd->proc_cls, NULL);
-      return;
+      cmd->buf[cmd->off] = '\0';
+      cmd->proc (cmd->proc_cls, cmd->buf);
     }
+    proc = cmd->proc;
+    cmd->proc = NULL;
+    proc (cmd->proc_cls, NULL);
+    return;
+  }
   end = memchr (&cmd->buf[cmd->off], '\n', ret);
   cmd->off += ret;
   while (end != NULL)
-    {
-      *end = '\0';
-      cmd->proc (cmd->proc_cls, cmd->buf);
-      memmove (cmd->buf, end + 1, cmd->off - (end + 1 - cmd->buf));
-      cmd->off -= (end + 1 - cmd->buf);
-      end = memchr (cmd->buf, '\n', cmd->off);
-    }
+  {
+    *end = '\0';
+    cmd->proc (cmd->proc_cls, cmd->buf);
+    memmove (cmd->buf, end + 1, cmd->off - (end + 1 - cmd->buf));
+    cmd->off -= (end + 1 - cmd->buf);
+    end = memchr (cmd->buf, '\n', cmd->off);
+  }
   cmd->rtask =
-    GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_absolute_get_remaining
-                                    (cmd->timeout), cmd->r, &cmd_read, cmd);
+      GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_absolute_get_remaining
+                                      (cmd->timeout), cmd->r, &cmd_read, cmd);
 }
 
 
@@ -1471,8 +1460,8 @@ cmd_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  */
 struct GNUNET_OS_CommandHandle *
 GNUNET_OS_command_run (GNUNET_OS_LineProcessor proc, void *proc_cls,
-                       struct GNUNET_TIME_Relative timeout,
-                       const char *binary, ...)
+                       struct GNUNET_TIME_Relative timeout, const char *binary,
+                       ...)
 {
   struct GNUNET_OS_CommandHandle *cmd;
   struct GNUNET_OS_Process *eip;
@@ -1486,10 +1475,10 @@ GNUNET_OS_command_run (GNUNET_OS_LineProcessor proc, void *proc_cls,
   eip = GNUNET_OS_start_process_va (NULL, opipe, binary, ap);
   va_end (ap);
   if (NULL == eip)
-    {
-      GNUNET_DISK_pipe_close (opipe);
-      return NULL;
-    }
+  {
+    GNUNET_DISK_pipe_close (opipe);
+    return NULL;
+  }
   GNUNET_DISK_pipe_close_end (opipe, GNUNET_DISK_PIPE_END_WRITE);
   cmd = GNUNET_malloc (sizeof (struct GNUNET_OS_CommandHandle));
   cmd->timeout = GNUNET_TIME_relative_to_absolute (timeout);
@@ -1498,8 +1487,7 @@ GNUNET_OS_command_run (GNUNET_OS_LineProcessor proc, void *proc_cls,
   cmd->proc = proc;
   cmd->proc_cls = proc_cls;
   cmd->r = GNUNET_DISK_pipe_handle (opipe, GNUNET_DISK_PIPE_END_READ);
-  cmd->rtask =
-    GNUNET_SCHEDULER_add_read_file (timeout, cmd->r, &cmd_read, cmd);
+  cmd->rtask = GNUNET_SCHEDULER_add_read_file (timeout, cmd->r, &cmd_read, cmd);
   return cmd;
 }