1 files changed, 353 insertions, 391 deletions

diff --git a/src/arm/gnunet-service-arm.c b/src/arm/gnunet-service-arm.c
index 05c6fb438..e4a8e7c6c 100644
--- a/src/arm/gnunet-service-arm.c
+++ b/src/arm/gnunet-service-arm.c
@@ -188,7 +188,7 @@ static struct GNUNET_SERVER_Handle *server;
  * @param cls closure, NULL if we need to self-restart
  * @param tc context
  */
-static void 
+static void
 config_change_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct ServiceList *pos;
@@ -196,21 +196,21 @@ config_change_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   pos = running_head;
   while (pos != NULL)
+  {
+    /* FIXME: this test for config change may be a bit too coarse grained */
+    if ((0 == STAT (pos->config, &sbuf)) &&
+        (pos->mtime < sbuf.st_mtime) && (pos->proc != NULL))
     {
-      /* FIXME: this test for config change may be a bit too coarse grained */
-      if ( (0 == STAT (pos->config, &sbuf)) && 
-           (pos->mtime < sbuf.st_mtime) &&
-           (pos->proc != NULL) )
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                      _("Restarting service `%s' due to configuration file change.\n"));
-          if (0 != GNUNET_OS_process_kill (pos->proc, SIGTERM))
-            GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-          else
-            pos->backoff = GNUNET_TIME_UNIT_MILLISECONDS;
-        }
-      pos = pos->next;
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _
+                  ("Restarting service `%s' due to configuration file change.\n"));
+      if (0 != GNUNET_OS_process_kill (pos->proc, SIGTERM))
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+      else
+        pos->backoff = GNUNET_TIME_UNIT_MILLISECONDS;
     }
+    pos = pos->next;
+  }
 }
 
 
@@ -229,15 +229,14 @@ write_result (void *cls, size_t size, void *buf)
   struct GNUNET_MessageHeader *msg;
 
   if (buf == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Could not send status result to client\n"));
-      return 0;                 /* error, not much we can do */
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("Could not send status result to client\n"));
+    return 0;                   /* error, not much we can do */
+  }
 #if DEBUG_ARM
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending status response %u to client\n",
-              (unsigned int) *res);
+              "Sending status response %u to client\n", (unsigned int) *res);
 #endif
   GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
   msg = buf;
@@ -259,29 +258,27 @@ write_result (void *cls, size_t size, void *buf)
  */
 static void
 signal_result (struct GNUNET_SERVER_Client *client,
-               const char *name, uint16_t result)
+               const char *name, uint16_t result)
 {
   uint16_t *res;
 
   if (NULL == client)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _
-                  ("Not sending status result to client: no client known\n"));
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _("Not sending status result to client: no client known\n"));
+    return;
+  }
 #if DEBUG_ARM
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Telling client that service `%s' is now %s\n",
-              name,
-              result == GNUNET_MESSAGE_TYPE_ARM_IS_DOWN ? "down" : "up");
+              "Telling client that service `%s' is now %s\n",
+              name, result == GNUNET_MESSAGE_TYPE_ARM_IS_DOWN ? "down" : "up");
 #endif
   res = GNUNET_malloc (sizeof (uint16_t));
   *res = result;
   GNUNET_SERVER_notify_transmit_ready (client,
-                                       sizeof (struct GNUNET_MessageHeader),
-                                       GNUNET_TIME_UNIT_FOREVER_REL,
-                                       &write_result, res);
+                                       sizeof (struct GNUNET_MessageHeader),
+                                       GNUNET_TIME_UNIT_FOREVER_REL,
+                                       &write_result, res);
 }
 
 
@@ -299,11 +296,11 @@ find_service (const char *name)
 
   pos = running_head;
   while (pos != NULL)
-    {
-      if (0 == strcmp (pos->name, name))
-        return pos;
-      pos = pos->next;
-    }
+  {
+    if (0 == strcmp (pos->name, name))
+      return pos;
+    pos = pos->next;
+  }
   return NULL;
 }
 
@@ -316,9 +313,7 @@ find_service (const char *name)
 static void
 free_service (struct ServiceList *pos)
 {
-  GNUNET_CONTAINER_DLL_remove (running_head,
-                               running_tail,
-                               pos);
+  GNUNET_CONTAINER_DLL_remove (running_head, running_tail, pos);
   GNUNET_free_non_null (pos->config);
   GNUNET_free_non_null (pos->binary);
   GNUNET_free (pos->name);
@@ -336,8 +331,7 @@ free_service (struct ServiceList *pos)
  * @param lsocks -1 terminated list of listen sockets to pass (systemd style), or NULL
  */
 static void
-start_process (struct ServiceList *sl,
-               const int *lsocks)
+start_process (struct ServiceList *sl, const int *lsocks)
 {
   char *loprefix;
   char *options;
@@ -351,85 +345,70 @@ start_process (struct ServiceList *sl,
   /* start service */
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_string (cfg,
-                                             sl->name, "PREFIX", &loprefix))
+                                             sl->name, "PREFIX", &loprefix))
     loprefix = GNUNET_strdup (prefix_command);
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_string (cfg,
-                                             sl->name, "OPTIONS", &options))
-    {      
-      options = GNUNET_strdup (final_option);
-      if (NULL == strstr (options, "%"))
-        {
-          /* replace '{}' with service name */
-          while (NULL != (optpos = strstr (options, "{}")))
-            {
-              optpos[0] = '%';
-              optpos[1] = 's';
-              GNUNET_asprintf (&optpos,
-                               options,
-                               sl->name);
-              GNUNET_free (options);
-              options = optpos;
-            }
-          /* replace '$PATH' with value associated with "PATH" */
-          while (NULL != (optpos = strstr (options, "$")))
-            {
-              optend = optpos + 1;
-              while (isupper ( (unsigned char) *optend)) optend++;            
-              b = *optend;
-              if ('\0' == b)
-                next = "";
-              else
-                next = optend+1;
-              *optend = '\0';
-              if (GNUNET_OK !=
-                  GNUNET_CONFIGURATION_get_value_string (cfg, "PATHS",
-                                                         optpos+1,
-                                                         &val))
-                val = GNUNET_strdup ("");
-              *optpos = '\0';
-              GNUNET_asprintf (&optpos,
-                               "%s%s%c%s",
-                               options,
-                               val,
-                               b,
-                               next);
-              GNUNET_free (options);
-              GNUNET_free (val);
-              options = optpos;
-            }
-        }
+                                             sl->name, "OPTIONS", &options))
+  {
+    options = GNUNET_strdup (final_option);
+    if (NULL == strstr (options, "%"))
+    {
+      /* replace '{}' with service name */
+      while (NULL != (optpos = strstr (options, "{}")))
+      {
+        optpos[0] = '%';
+        optpos[1] = 's';
+        GNUNET_asprintf (&optpos, options, sl->name);
+        GNUNET_free (options);
+        options = optpos;
+      }
+      /* replace '$PATH' with value associated with "PATH" */
+      while (NULL != (optpos = strstr (options, "$")))
+      {
+        optend = optpos + 1;
+        while (isupper ((unsigned char) *optend))
+          optend++;
+        b = *optend;
+        if ('\0' == b)
+          next = "";
+        else
+          next = optend + 1;
+        *optend = '\0';
+        if (GNUNET_OK !=
+            GNUNET_CONFIGURATION_get_value_string (cfg, "PATHS",
+                                                   optpos + 1, &val))
+          val = GNUNET_strdup ("");
+        *optpos = '\0';
+        GNUNET_asprintf (&optpos, "%s%s%c%s", options, val, b, next);
+        GNUNET_free (options);
+        GNUNET_free (val);
+        options = optpos;
+      }
     }
+  }
   use_debug = GNUNET_CONFIGURATION_get_value_yesno (cfg, sl->name, "DEBUG");
 
 #if DEBUG_ARM
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting service `%s' using binary `%s' and configuration `%s'\n",
-              sl->name, sl->binary, sl->config);
+              "Starting service `%s' using binary `%s' and configuration `%s'\n",
+              sl->name, sl->binary, sl->config);
 #endif
   if (GNUNET_YES == use_debug)
     sl->proc = do_start_process (lsocks,
-                                loprefix,                               
-                                sl->binary,
-                                "-c", sl->config,
-                                "-L", "DEBUG",
-                                options,
-                                NULL);
+                                 loprefix,
+                                 sl->binary,
+                                 "-c", sl->config,
+                                 "-L", "DEBUG", options, NULL);
   else
     sl->proc = do_start_process (lsocks,
-                                loprefix,
-                                sl->binary,
-                                "-c", sl->config,
-                                options,
-                                NULL);
+                                 loprefix,
+                                 sl->binary, "-c", sl->config, options, NULL);
   if (sl->proc == NULL)
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
-                _("Failed to start service `%s'\n"), 
-                sl->name);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Failed to start service `%s'\n"), sl->name);
   else
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO, 
-                _("Starting service `%s'\n"), 
-                sl->name);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Starting service `%s'\n"), sl->name);
   GNUNET_free (loprefix);
   GNUNET_free (options);
 }
@@ -444,9 +423,8 @@ start_process (struct ServiceList *sl,
  * @return GNUNET_OK on success, GNUNET_SYSERR on error
  */
 int
-start_service (struct GNUNET_SERVER_Client *client, 
-               const char *servicename,
-               const int *lsocks)
+start_service (struct GNUNET_SERVER_Client *client,
+               const char *servicename, const int *lsocks)
 {
   struct ServiceList *sl;
   char *binary;
@@ -454,46 +432,46 @@ start_service (struct GNUNET_SERVER_Client *client,
   struct stat sbuf;
 
   if (GNUNET_YES == in_shutdown)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _("ARM is shutting down, service `%s' not started.\n"),
-                  servicename);
-      signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _("ARM is shutting down, service `%s' not started.\n"),
+                servicename);
+    signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
+    return GNUNET_SYSERR;
+  }
   sl = find_service (servicename);
   if (sl != NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  _("Service `%s' already running.\n"), servicename);
-      signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_UP);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                _("Service `%s' already running.\n"), servicename);
+    signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_UP);
+    return GNUNET_SYSERR;
+  }
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_string (cfg,
-                                             servicename, "BINARY", &binary))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Binary implementing service `%s' not known!\n"),
-                  servicename);
-      signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
-      return GNUNET_SYSERR;
-    }
+                                             servicename, "BINARY", &binary))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("Binary implementing service `%s' not known!\n"),
+                servicename);
+    signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
+    return GNUNET_SYSERR;
+  }
   if ((GNUNET_OK !=
        GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                                servicename,
-                                                "CONFIG",
-                                                &config)) ||
+                                                servicename,
+                                                "CONFIG",
+                                                &config)) ||
       (0 != STAT (config, &sbuf)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Configuration file `%s' for service `%s' not known!\n"),
-                  config, servicename);
-      signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
-      GNUNET_free (binary);
-      GNUNET_free_non_null (config);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("Configuration file `%s' for service `%s' not known!\n"),
+                config, servicename);
+    signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
+    GNUNET_free (binary);
+    GNUNET_free_non_null (config);
+    return GNUNET_SYSERR;
+  }
   (void) stop_listening (servicename);
   sl = GNUNET_malloc (sizeof (struct ServiceList));
   sl->name = GNUNET_strdup (servicename);
@@ -502,9 +480,7 @@ start_service (struct GNUNET_SERVER_Client *client,
   sl->mtime = sbuf.st_mtime;
   sl->backoff = GNUNET_TIME_UNIT_MILLISECONDS;
   sl->restartAt = GNUNET_TIME_UNIT_FOREVER_ABS;
-  GNUNET_CONTAINER_DLL_insert (running_head,
-                               running_tail,
-                               sl);
+  GNUNET_CONTAINER_DLL_insert (running_head, running_tail, sl);
   start_process (sl, lsocks);
   if (NULL != client)
     signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_UP);
@@ -519,58 +495,57 @@ start_service (struct GNUNET_SERVER_Client *client,
  * @param servicename name of the service to stop
  */
 static void
-stop_service (struct GNUNET_SERVER_Client *client,
-              const char *servicename)
+stop_service (struct GNUNET_SERVER_Client *client, const char *servicename)
 {
   struct ServiceList *pos;
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _("Preparing to stop `%s'\n"), servicename);
+              _("Preparing to stop `%s'\n"), servicename);
   pos = find_service (servicename);
   if (pos == NULL)
-    {
-      if (GNUNET_OK == stop_listening (servicename))
-        signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
-      else
-        signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_UNKNOWN);
-      GNUNET_SERVER_receive_done (client, GNUNET_OK);
-      return;
-    }
+  {
+    if (GNUNET_OK == stop_listening (servicename))
+      signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
+    else
+      signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_UNKNOWN);
+    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    return;
+  }
   if (pos->killing_client != NULL)
-    {
-      /* killing already in progress */
+  {
+    /* killing already in progress */
 #if DEBUG_ARM
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Service `%s' is already down\n", servicename);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Service `%s' is already down\n", servicename);
 #endif
-      signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
-      GNUNET_SERVER_receive_done (client, GNUNET_OK);
-      return;
-    }
+    signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
+    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    return;
+  }
 
   if (GNUNET_YES == in_shutdown)
-    {
+  {
 #if DEBUG_ARM
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Termination request already sent to `%s' (since ARM is in shutdown).\n",
-                  servicename);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Termination request already sent to `%s' (since ARM is in shutdown).\n",
+                servicename);
 #endif
-      signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
-      GNUNET_SERVER_receive_done (client, GNUNET_OK);
-      return;
-    }
+    signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
+    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    return;
+  }
   if (pos->proc == NULL)
-    {
-      /* process is in delayed restart, simply remove it! */
-      free_service (pos);
-      signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
-      GNUNET_SERVER_receive_done (client, GNUNET_OK);
-      return;
-    }
+  {
+    /* process is in delayed restart, simply remove it! */
+    free_service (pos);
+    signal_result (client, servicename, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
+    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    return;
+  }
 #if DEBUG_ARM
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending kill signal to service `%s', waiting for process to die.\n",
-              servicename);
+              "Sending kill signal to service `%s', waiting for process to die.\n",
+              servicename);
 #endif
   if (0 != GNUNET_OS_process_kill (pos->proc, SIGTERM))
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
@@ -590,8 +565,8 @@ stop_service (struct GNUNET_SERVER_Client *client,
  */
 static void
 handle_start (void *cls,
-              struct GNUNET_SERVER_Client *client,
-              const struct GNUNET_MessageHeader *message)
+              struct GNUNET_SERVER_Client *client,
+              const struct GNUNET_MessageHeader *message)
 {
   const char *servicename;
   uint16_t size;
@@ -600,11 +575,11 @@ handle_start (void *cls,
   size -= sizeof (struct GNUNET_MessageHeader);
   servicename = (const char *) &message[1];
   if ((size == 0) || (servicename[size - 1] != '\0'))
-    {
-      GNUNET_break (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   start_service (client, servicename, NULL);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
@@ -621,8 +596,8 @@ handle_start (void *cls,
  */
 static void
 handle_stop (void *cls,
-             struct GNUNET_SERVER_Client *client,
-             const struct GNUNET_MessageHeader *message)
+             struct GNUNET_SERVER_Client *client,
+             const struct GNUNET_MessageHeader *message)
 {
   const char *servicename;
   uint16_t size;
@@ -631,11 +606,11 @@ handle_stop (void *cls,
   size -= sizeof (struct GNUNET_MessageHeader);
   servicename = (const char *) &message[1];
   if ((size == 0) || (servicename[size - 1] != '\0'))
-    {
-      GNUNET_break (0);
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   stop_service (client, servicename);
 }
 
@@ -650,14 +625,14 @@ clean_up_running ()
 {
   struct ServiceList *pos;
   struct ServiceList *next;
- 
+
   next = running_head;
   while (NULL != (pos = next))
-    {
-      next = pos->next;
-      if (pos->proc == NULL)
-        free_service (pos);     
-    }
+  {
+    next = pos->next;
+    if (pos->proc == NULL)
+      free_service (pos);
+  }
 }
 
 
@@ -669,15 +644,15 @@ static void
 do_shutdown ()
 {
   if (NULL != server)
-    {
-      GNUNET_SERVER_destroy (server);
-      server = NULL;
-    }
+  {
+    GNUNET_SERVER_destroy (server);
+    server = NULL;
+  }
   if (GNUNET_SCHEDULER_NO_TASK != child_death_task)
-    {
-      GNUNET_SCHEDULER_cancel (child_death_task);
-      child_death_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (child_death_task);
+    child_death_task = GNUNET_SCHEDULER_NO_TASK;
+  }
 }
 
 
@@ -688,35 +663,31 @@ do_shutdown ()
  * @param tc context
  */
 static void
-shutdown_task (void *cls, 
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct ServiceList *pos;
 
 #if DEBUG_ARM
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-              _("Stopping all services\n"));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Stopping all services\n"));
 #endif
   if (GNUNET_SCHEDULER_NO_TASK != child_restart_task)
-    {
-      GNUNET_SCHEDULER_cancel (child_restart_task);
-      child_restart_task  = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (child_restart_task);
+    child_restart_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   in_shutdown = GNUNET_YES;
   stop_listening (NULL);
   pos = running_head;
   while (NULL != pos)
+  {
+    if (pos->proc != NULL)
     {
-      if (pos->proc != NULL)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                      "Stopping service `%s'\n",
-                      pos->name);
-          if (0 != GNUNET_OS_process_kill (pos->proc, SIGTERM))
-            GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-        }
-      pos = pos->next;
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Stopping service `%s'\n", pos->name);
+      if (0 != GNUNET_OS_process_kill (pos->proc, SIGTERM))
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
     }
+    pos = pos->next;
+  }
   if (running_head == NULL)
     do_shutdown ();
 }
@@ -741,40 +712,39 @@ delayed_restart_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   lowestRestartDelay = GNUNET_TIME_UNIT_FOREVER_REL;
 
   /* check for services that need to be restarted due to
-     configuration changes or because the last restart failed */
+   * configuration changes or because the last restart failed */
   pos = running_head;
   while (pos != NULL)
+  {
+    if (pos->proc == NULL)
     {
-      if (pos->proc == NULL) 
-        {
-          if (GNUNET_TIME_absolute_get_remaining (pos->restartAt).rel_value == 0)
-            {
-              GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                          _("Restarting service `%s'.\n"), pos->name);
-              start_process (pos, NULL);
-            }
-          else
-            {
-              lowestRestartDelay 
-                = GNUNET_TIME_relative_min (lowestRestartDelay,
-                                            GNUNET_TIME_absolute_get_remaining
-                                            (pos->restartAt));
-            }
-        }
-      pos = pos->next;
-    }  
+      if (GNUNET_TIME_absolute_get_remaining (pos->restartAt).rel_value == 0)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                    _("Restarting service `%s'.\n"), pos->name);
+        start_process (pos, NULL);
+      }
+      else
+      {
+        lowestRestartDelay
+            = GNUNET_TIME_relative_min (lowestRestartDelay,
+                                        GNUNET_TIME_absolute_get_remaining
+                                        (pos->restartAt));
+      }
+    }
+    pos = pos->next;
+  }
   if (lowestRestartDelay.rel_value != GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
-    {
+  {
 #if DEBUG_ARM
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Will restart process in %llums\n",
-                  (unsigned long long) lowestRestartDelay.rel_value);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Will restart process in %llums\n",
+                (unsigned long long) lowestRestartDelay.rel_value);
 #endif
-      child_restart_task
-        = GNUNET_SCHEDULER_add_delayed (lowestRestartDelay,
-                                        &delayed_restart_task,
-                                        NULL);
-    }
+    child_restart_task
+        = GNUNET_SCHEDULER_add_delayed (lowestRestartDelay,
+                                        &delayed_restart_task, NULL);
+  }
 }
 
 
@@ -786,8 +756,7 @@ delayed_restart_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @param tc context
  */
 static void
-maint_child_death (void *cls,
-                   const struct GNUNET_SCHEDULER_TaskContext *tc)
+maint_child_death (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct ServiceList *pos;
   struct ServiceList *next;
@@ -800,93 +769,89 @@ maint_child_death (void *cls,
 
   child_death_task = GNUNET_SCHEDULER_NO_TASK;
   if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
-    {
-      /* shutdown scheduled us, ignore! */
-      child_death_task =
-        GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, pr,
-                                        &maint_child_death, NULL);
-      return;    
-    }
+  {
+    /* shutdown scheduled us, ignore! */
+    child_death_task =
+        GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, pr,
+                                        &maint_child_death, NULL);
+    return;
+  }
   /* consume the signal */
   GNUNET_break (0 < GNUNET_DISK_file_read (pr, &c, sizeof (c)));
 
   /* check for services that died (WAITPID) */
   next = running_head;
   while (NULL != (pos = next))
+  {
+    next = pos->next;
+    if (pos->proc == NULL)
+      continue;
+    if ((GNUNET_SYSERR == (ret = GNUNET_OS_process_status (pos->proc,
+                                                           &statusType,
+                                                           &statusCode))) ||
+        ((ret == GNUNET_NO) ||
+         (statusType == GNUNET_OS_PROCESS_STOPPED) ||
+         (statusType == GNUNET_OS_PROCESS_RUNNING)))
+      continue;
+
+    if (statusType == GNUNET_OS_PROCESS_EXITED)
     {
-      next = pos->next;
-      if (pos->proc == NULL) 
-        continue;
-      if ((GNUNET_SYSERR == (ret = GNUNET_OS_process_status (pos->proc,
-                                                             &statusType,
-                                                             &statusCode))) ||
-          ( (ret == GNUNET_NO) ||
-            (statusType == GNUNET_OS_PROCESS_STOPPED) ||
-            (statusType == GNUNET_OS_PROCESS_RUNNING)) )
-        continue;       
-
-      if (statusType == GNUNET_OS_PROCESS_EXITED)
-        {
-          statstr = _( /* process termination method */ "exit");
-          statcode = statusCode;
-        }
-      else if (statusType == GNUNET_OS_PROCESS_SIGNALED)
-        {
-          statstr = _( /* process termination method */ "signal");
-          statcode = statusCode;
-        }
-      else
-        {
-          statstr = _( /* process termination method */ "unknown");
-          statcode = 0;
-        }
-      GNUNET_OS_process_close (pos->proc);
-      pos->proc = NULL;
-      if (NULL != pos->killing_client) 
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_INFO, 
-                      _("Service `%s' stopped\n"),
-                      pos->name);
-          signal_result (pos->killing_client, 
-                         pos->name, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
-          GNUNET_SERVER_receive_done (pos->killing_client, GNUNET_OK);
-          GNUNET_SERVER_client_drop (pos->killing_client);
-          free_service (pos);
-          continue;
-        }
-      if (GNUNET_YES != in_shutdown) 
-        {
-          if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-            GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                        _("Service `%s' terminated with status %s/%d, will try to restart it!\n"),
-                        pos->name, statstr, statcode);
-          /* schedule restart */
-          pos->restartAt
-            = GNUNET_TIME_relative_to_absolute (pos->backoff);
-          if (pos->backoff.rel_value < EXPONENTIAL_BACKOFF_THRESHOLD)
-            pos->backoff 
-              = GNUNET_TIME_relative_multiply (pos->backoff, 2);
-          if (GNUNET_SCHEDULER_NO_TASK != child_restart_task)
-            GNUNET_SCHEDULER_cancel (child_restart_task);
-          child_restart_task 
-            = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                                  &delayed_restart_task,
-                                                  NULL);
-        }
+      statstr = _( /* process termination method */ "exit");
+      statcode = statusCode;
+    }
+    else if (statusType == GNUNET_OS_PROCESS_SIGNALED)
+    {
+      statstr = _( /* process termination method */ "signal");
+      statcode = statusCode;
+    }
+    else
+    {
+      statstr = _( /* process termination method */ "unknown");
+      statcode = 0;
+    }
+    GNUNET_OS_process_close (pos->proc);
+    pos->proc = NULL;
+    if (NULL != pos->killing_client)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _("Service `%s' stopped\n"), pos->name);
+      signal_result (pos->killing_client,
+                     pos->name, GNUNET_MESSAGE_TYPE_ARM_IS_DOWN);
+      GNUNET_SERVER_receive_done (pos->killing_client, GNUNET_OK);
+      GNUNET_SERVER_client_drop (pos->killing_client);
+      free_service (pos);
+      continue;
+    }
+    if (GNUNET_YES != in_shutdown)
+    {
+      if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    _
+                    ("Service `%s' terminated with status %s/%d, will try to restart it!\n"),
+                    pos->name, statstr, statcode);
+      /* schedule restart */
+      pos->restartAt = GNUNET_TIME_relative_to_absolute (pos->backoff);
+      if (pos->backoff.rel_value < EXPONENTIAL_BACKOFF_THRESHOLD)
+        pos->backoff = GNUNET_TIME_relative_multiply (pos->backoff, 2);
+      if (GNUNET_SCHEDULER_NO_TASK != child_restart_task)
+        GNUNET_SCHEDULER_cancel (child_restart_task);
+      child_restart_task
+          = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                                &delayed_restart_task, NULL);
+    }
 #if DEBUG_ARM
-      else
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "Service `%s' terminated with status %s/%d\n",
-                    pos->name, statstr, statcode);
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Service `%s' terminated with status %s/%d\n",
+                  pos->name, statstr, statcode);
 #endif
-    }
+  }
   child_death_task =
-    GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, pr,
-                                    &maint_child_death, NULL); 
+      GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, pr,
+                                      &maint_child_death, NULL);
   if (GNUNET_YES == in_shutdown)
     clean_up_running ();
-  if ( (NULL == running_head) &&
-       (GNUNET_YES == in_shutdown) )
+  if ((NULL == running_head) && (GNUNET_YES == in_shutdown))
     do_shutdown ();
 }
 
@@ -898,25 +863,24 @@ transmit_shutdown_ack (void *cls, size_t size, void *buf)
   struct GNUNET_MessageHeader *msg;
 
   if (size < sizeof (struct GNUNET_MessageHeader))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _("Failed to transmit shutdown ACK.\n"));
-      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-      return 0;                 /* client disconnected */
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _("Failed to transmit shutdown ACK.\n"));
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return 0;                   /* client disconnected */
+  }
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _("Transmitting shutdown ACK.\n"));
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Transmitting shutdown ACK.\n"));
 
   /* Make the connection flushing for the purpose of ACK transmitting,
-     needed on W32 to ensure that the message is even received, harmless
-     on other platforms... */
+   * needed on W32 to ensure that the message is even received, harmless
+   * on other platforms... */
   GNUNET_break (GNUNET_OK == GNUNET_SERVER_client_disable_corking (client));
   msg = (struct GNUNET_MessageHeader *) buf;
   msg->type = htons (GNUNET_MESSAGE_TYPE_ARM_SHUTDOWN_ACK);
   msg->size = htons (sizeof (struct GNUNET_MessageHeader));
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
-  GNUNET_SERVER_client_drop(client);
+  GNUNET_SERVER_client_drop (client);
   return sizeof (struct GNUNET_MessageHeader);
 }
 
@@ -933,11 +897,11 @@ handle_shutdown (void *cls,
                  struct GNUNET_SERVER_Client *client,
                  const struct GNUNET_MessageHeader *message)
 {
-  GNUNET_SERVER_client_keep(client);
+  GNUNET_SERVER_client_keep (client);
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               _("Initiating shutdown as requested by client.\n"));
   GNUNET_SERVER_notify_transmit_ready (client,
-                                       sizeof(struct GNUNET_MessageHeader),
+                                       sizeof (struct GNUNET_MessageHeader),
                                        GNUNET_TIME_UNIT_FOREVER_REL,
                                        &transmit_shutdown_ack, client);
   GNUNET_SERVER_client_persist_ (client);
@@ -953,12 +917,13 @@ static void
 sighandler_child_death ()
 {
   static char c;
-  int old_errno = errno; /* back-up errno */
-  GNUNET_break (1 == 
-                GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle
-                                        (sigpipe, GNUNET_DISK_PIPE_END_WRITE), &c,
-                                        sizeof (c)));
-  errno = old_errno; /* restore errno */
+  int old_errno = errno;        /* back-up errno */
+
+  GNUNET_break (1 ==
+                GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle
+                                        (sigpipe, GNUNET_DISK_PIPE_END_WRITE),
+                                        &c, sizeof (c)));
+  errno = old_errno;            /* restore errno */
 }
 
 
@@ -991,63 +956,59 @@ run (void *cls,
   GNUNET_assert (pr != NULL);
   GNUNET_SERVER_ignore_shutdown (serv, GNUNET_YES);
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
-                                &shutdown_task,
-                                NULL);
+                                &shutdown_task, NULL);
   child_death_task =
-    GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, pr,
-                                    &maint_child_death, NULL);
+      GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, pr,
+                                      &maint_child_death, NULL);
 
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_string (cfg,
-                                             "ARM",
-                                             "GLOBAL_PREFIX",
-                                             &prefix_command))
+                                             "ARM",
+                                             "GLOBAL_PREFIX", &prefix_command))
     prefix_command = GNUNET_strdup ("");
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_string (cfg,
-                                             "ARM",
-                                             "GLOBAL_POSTFIX",
-                                             &final_option))
+                                             "ARM",
+                                             "GLOBAL_POSTFIX", &final_option))
     final_option = GNUNET_strdup ("");
   /* start default services... */
   if (GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_string (cfg,
-                                             "ARM",
-                                             "DEFAULTSERVICES",
-                                             &defaultservices))
-    {
+                                             "ARM",
+                                             "DEFAULTSERVICES",
+                                             &defaultservices))
+  {
 #if DEBUG_ARM
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Starting default services `%s'\n", defaultservices);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Starting default services `%s'\n", defaultservices);
 #endif
-      if (0 < strlen (defaultservices))
-        {
-          pos = strtok (defaultservices, " ");
-          while (pos != NULL)
-            {
-              start_service (NULL, pos, NULL);
-              pos = strtok (NULL, " ");
-            }
-        }
-      GNUNET_free (defaultservices);
+    if (0 < strlen (defaultservices))
+    {
+      pos = strtok (defaultservices, " ");
+      while (pos != NULL)
+      {
+        start_service (NULL, pos, NULL);
+        pos = strtok (NULL, " ");
+      }
     }
+    GNUNET_free (defaultservices);
+  }
   else
-    {
+  {
 #if DEBUG_ARM
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "No default services configured.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No default services configured.\n");
 #endif
-    }
+  }
 
-  /* create listening sockets for future services*/
+  /* create listening sockets for future services */
   prepareServices (cfg);
-  
+
   /* process client requests */
   GNUNET_SERVER_add_handlers (server, handlers);
 
   /* manage services */
   GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                      &config_change_task, NULL);
+                                      &config_change_task, NULL);
 }
 
 
@@ -1066,10 +1027,11 @@ main (int argc, char *const *argv)
 
   sigpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_NO);
   GNUNET_assert (sigpipe != NULL);
-  shc_chld = GNUNET_SIGNAL_handler_install (GNUNET_SIGCHLD, &sighandler_child_death);
-  ret = (GNUNET_OK ==
-         GNUNET_SERVICE_run (argc,
-                             argv, "arm", GNUNET_YES, &run, NULL)) ? 0 : 1;
+  shc_chld =
+      GNUNET_SIGNAL_handler_install (GNUNET_SIGCHLD, &sighandler_child_death);
+  ret =
+      (GNUNET_OK ==
+       GNUNET_SERVICE_run (argc, argv, "arm", GNUNET_YES, &run, NULL)) ? 0 : 1;
   GNUNET_SIGNAL_handler_uninstall (shc_chld);
   shc_chld = NULL;
   GNUNET_DISK_pipe_close (sigpipe);
@@ -1085,8 +1047,8 @@ main (int argc, char *const *argv)
  */
 void __attribute__ ((constructor)) GNUNET_ARM_memory_init ()
 {
-  mallopt (M_TRIM_THRESHOLD, 4*1024);
-  mallopt (M_TOP_PAD, 1*1024);
+  mallopt (M_TRIM_THRESHOLD, 4 * 1024);
+  mallopt (M_TOP_PAD, 1 * 1024);
   malloc_trim (0);
 }
 #endif