1 files changed, 1216 insertions, 1143 deletions

diff --git a/src/arm/gnunet-service-arm.c b/src/arm/gnunet-service-arm.c
index e02314b91..d13be6eb1 100644
--- a/src/arm/gnunet-service-arm.c
+++ b/src/arm/gnunet-service-arm.c
@@ -29,10 +29,10 @@
 #include "gnunet_protocols.h"
 #include "arm.h"
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "util", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "util", __VA_ARGS__)
 
 #define LOG_STRERROR(kind, syscall) \
-  GNUNET_log_from_strerror(kind, "util", syscall)
+  GNUNET_log_from_strerror (kind, "util", syscall)
 
 
 #if HAVE_WAIT4
@@ -65,7 +65,8 @@ struct ServiceList;
 /**
  * Record with information about a listen socket we have open.
  */
-struct ServiceListeningInfo {
+struct ServiceListeningInfo
+{
   /**
    * This is a linked list.
    */
@@ -106,7 +107,8 @@ struct ServiceListeningInfo {
 /**
  * List of our services.
  */
-struct ServiceList {
+struct ServiceList
+{
   /**
    * This is a doubly-linked list.
    */
@@ -164,6 +166,11 @@ struct ServiceList {
   struct GNUNET_TIME_Relative backoff;
 
   /**
+   * Absolute time at which the process was (re-)started last.
+   */
+  struct GNUNET_TIME_Absolute last_started_at;
+
+  /**
    * Absolute time at which the process is scheduled to restart in case of death
    */
   struct GNUNET_TIME_Absolute restart_at;
@@ -186,6 +193,11 @@ struct ServiceList {
    * are on Windoze).
    */
   int pipe_control;
+
+  /**
+   * Last exit status of the process.
+   */
+  int last_exit_status;
 };
 
 /**
@@ -278,30 +290,30 @@ static struct GNUNET_NotificationContext *notifier;
  *          parameter is ignore on systems other than LINUX
  */
 static void
-add_unixpath(struct sockaddr **saddrs,
-             socklen_t *saddrlens,
-             const char *unixpath,
-             int abstract)
+add_unixpath (struct sockaddr **saddrs,
+              socklen_t *saddrlens,
+              const char *unixpath,
+              int abstract)
 {
 #ifdef AF_UNIX
   struct sockaddr_un *un;
 
-  un = GNUNET_new(struct sockaddr_un);
+  un = GNUNET_new (struct sockaddr_un);
   un->sun_family = AF_UNIX;
-  GNUNET_strlcpy(un->sun_path, unixpath, sizeof(un->sun_path));
+  GNUNET_strlcpy (un->sun_path, unixpath, sizeof(un->sun_path));
 #ifdef LINUX
   if (GNUNET_YES == abstract)
     un->sun_path[0] = '\0';
 #endif
 #if HAVE_SOCKADDR_UN_SUN_LEN
-  un->sun_len = (u_char)sizeof(struct sockaddr_un);
+  un->sun_len = (u_char) sizeof(struct sockaddr_un);
 #endif
-  *saddrs = (struct sockaddr *)un;
+  *saddrs = (struct sockaddr *) un;
   *saddrlens = sizeof(struct sockaddr_un);
 #else
   /* this function should never be called
    * unless AF_UNIX is defined! */
-  GNUNET_assert(0);
+  GNUNET_assert (0);
 #endif
 }
 
@@ -327,10 +339,10 @@ add_unixpath(struct sockaddr **saddrs,
  *              set to NULL).
  */
 static int
-get_server_addresses(const char *service_name,
-                     const struct GNUNET_CONFIGURATION_Handle *cfg,
-                     struct sockaddr ***addrs,
-                     socklen_t **addr_lens)
+get_server_addresses (const char *service_name,
+                      const struct GNUNET_CONFIGURATION_Handle *cfg,
+                      struct sockaddr ***addrs,
+                      socklen_t **addr_lens)
 {
   int disablev6;
   struct GNUNET_NETWORK_Handle *desc;
@@ -351,72 +363,72 @@ get_server_addresses(const char *service_name,
   *addrs = NULL;
   *addr_lens = NULL;
   desc = NULL;
-  if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "DISABLEV6"))
-    {
-      if (GNUNET_SYSERR ==
-          (disablev6 = GNUNET_CONFIGURATION_get_value_yesno(cfg,
-                                                            service_name,
-                                                            "DISABLEV6")))
-        return GNUNET_SYSERR;
-    }
+  if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "DISABLEV6"))
+  {
+    if (GNUNET_SYSERR ==
+        (disablev6 = GNUNET_CONFIGURATION_get_value_yesno (cfg,
+                                                           service_name,
+                                                           "DISABLEV6")))
+      return GNUNET_SYSERR;
+  }
   else
     disablev6 = GNUNET_NO;
 
-  if (!disablev6)
+  if (! disablev6)
+  {
+    /* probe IPv6 support */
+    desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0);
+    if (NULL == desc)
     {
-      /* probe IPv6 support */
-      desc = GNUNET_NETWORK_socket_create(PF_INET6, SOCK_STREAM, 0);
-      if (NULL == desc)
-        {
-          if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) ||
-              (EACCES == errno))
-            {
-              LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "socket");
-              return GNUNET_SYSERR;
-            }
-          LOG(GNUNET_ERROR_TYPE_INFO,
-              _(
-                "Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"),
-              service_name,
-              strerror(errno));
-          disablev6 = GNUNET_YES;
-        }
-      else
-        {
-          GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(desc));
-          desc = NULL;
-        }
+      if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) ||
+          (EACCES == errno))
+      {
+        LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket");
+        return GNUNET_SYSERR;
+      }
+      LOG (GNUNET_ERROR_TYPE_INFO,
+           _ (
+             "Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"),
+           service_name,
+           strerror (errno));
+      disablev6 = GNUNET_YES;
     }
+    else
+    {
+      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc));
+      desc = NULL;
+    }
+  }
 
   port = 0;
-  if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "PORT"))
+  if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "PORT"))
+  {
+    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                            service_name,
+                                                            "PORT",
+                                                            &port))
     {
-      if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                             service_name,
-                                                             "PORT",
-                                                             &port))
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR,
-              _("Require valid port number for service `%s' in configuration!\n"),
-              service_name);
-        }
-      if (port > 65535)
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR,
-              _("Require valid port number for service `%s' in configuration!\n"),
-              service_name);
-          return GNUNET_SYSERR;
-        }
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           _ ("Require valid port number for service `%s' in configuration!\n"),
+           service_name);
     }
-
-  if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "BINDTO"))
+    if (port > 65535)
     {
-      GNUNET_break(GNUNET_OK ==
-                   GNUNET_CONFIGURATION_get_value_string(cfg,
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           _ ("Require valid port number for service `%s' in configuration!\n"),
+           service_name);
+      return GNUNET_SYSERR;
+    }
+  }
+
+  if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "BINDTO"))
+  {
+    GNUNET_break (GNUNET_OK ==
+                  GNUNET_CONFIGURATION_get_value_string (cfg,
                                                          service_name,
                                                          "BINDTO",
                                                          &hostname));
-    }
+  }
   else
     hostname = NULL;
 
@@ -424,235 +436,235 @@ get_server_addresses(const char *service_name,
   abstract = GNUNET_NO;
 #ifdef AF_UNIX
   if ((GNUNET_YES ==
-       GNUNET_CONFIGURATION_have_value(cfg, service_name, "UNIXPATH")) &&
-      (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename(cfg,
-                                                            service_name,
-                                                            "UNIXPATH",
-                                                            &unixpath)) &&
-      (0 < strlen(unixpath)))
-    {
-      /* probe UNIX support */
-      struct sockaddr_un s_un;
+       GNUNET_CONFIGURATION_have_value (cfg, service_name, "UNIXPATH")) &&
+      (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                                             service_name,
+                                                             "UNIXPATH",
+                                                             &unixpath)) &&
+      (0 < strlen (unixpath)))
+  {
+    /* probe UNIX support */
+    struct sockaddr_un s_un;
 
-      if (strlen(unixpath) >= sizeof(s_un.sun_path))
-        {
-          LOG(GNUNET_ERROR_TYPE_WARNING,
-              _("UNIXPATH `%s' too long, maximum length is %llu\n"),
-              unixpath,
-              (unsigned long long)sizeof(s_un.sun_path));
-          unixpath = GNUNET_NETWORK_shorten_unixpath(unixpath);
-          LOG(GNUNET_ERROR_TYPE_INFO, _("Using `%s' instead\n"), unixpath);
-        }
+    if (strlen (unixpath) >= sizeof(s_un.sun_path))
+    {
+      LOG (GNUNET_ERROR_TYPE_WARNING,
+           _ ("UNIXPATH `%s' too long, maximum length is %llu\n"),
+           unixpath,
+           (unsigned long long) sizeof(s_un.sun_path));
+      unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath);
+      LOG (GNUNET_ERROR_TYPE_INFO, _ ("Using `%s' instead\n"), unixpath);
+    }
 #ifdef LINUX
-      abstract = GNUNET_CONFIGURATION_get_value_yesno(cfg,
-                                                      "TESTING",
-                                                      "USE_ABSTRACT_SOCKETS");
-      if (GNUNET_SYSERR == abstract)
-        abstract = GNUNET_NO;
+    abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg,
+                                                     "TESTING",
+                                                     "USE_ABSTRACT_SOCKETS");
+    if (GNUNET_SYSERR == abstract)
+      abstract = GNUNET_NO;
 #endif
-      if ((GNUNET_YES != abstract) &&
-          (GNUNET_OK != GNUNET_DISK_directory_create_for_file(unixpath)))
-        GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "mkdir", unixpath);
-    }
+    if ((GNUNET_YES != abstract) &&
+        (GNUNET_OK != GNUNET_DISK_directory_create_for_file (unixpath)))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "mkdir", unixpath);
+  }
   if (NULL != unixpath)
+  {
+    desc = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0);
+    if (NULL == desc)
     {
-      desc = GNUNET_NETWORK_socket_create(AF_UNIX, SOCK_STREAM, 0);
-      if (NULL == desc)
-        {
-          if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) ||
-              (EACCES == errno))
-            {
-              LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "socket");
-              GNUNET_free_non_null(hostname);
-              GNUNET_free(unixpath);
-              return GNUNET_SYSERR;
-            }
-          LOG(GNUNET_ERROR_TYPE_INFO,
-              _(
-                "Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"),
-              service_name,
-              strerror(errno));
-          GNUNET_free(unixpath);
-          unixpath = NULL;
-        }
-      else
-        {
-          GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(desc));
-          desc = NULL;
-        }
+      if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) ||
+          (EACCES == errno))
+      {
+        LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket");
+        GNUNET_free_non_null (hostname);
+        GNUNET_free (unixpath);
+        return GNUNET_SYSERR;
+      }
+      LOG (GNUNET_ERROR_TYPE_INFO,
+           _ (
+             "Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"),
+           service_name,
+           strerror (errno));
+      GNUNET_free (unixpath);
+      unixpath = NULL;
+    }
+    else
+    {
+      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc));
+      desc = NULL;
     }
+  }
 #endif
 
   if ((0 == port) && (NULL == unixpath))
+  {
+    if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (cfg,
+                                                            service_name,
+                                                            "START_ON_DEMAND"))
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           _ (
+             "Have neither PORT nor UNIXPATH for service `%s', but one is required\n"),
+           service_name);
+    GNUNET_free_non_null (hostname);
+    return GNUNET_SYSERR;
+  }
+  if (0 == port)
+  {
+    saddrs = GNUNET_new_array (2, struct sockaddr *);
+    saddrlens = GNUNET_new_array (2, socklen_t);
+    add_unixpath (saddrs, saddrlens, unixpath, abstract);
+    GNUNET_free_non_null (unixpath);
+    GNUNET_free_non_null (hostname);
+    *addrs = saddrs;
+    *addr_lens = saddrlens;
+    return 1;
+  }
+
+  if (NULL != hostname)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Resolving `%s' since that is where `%s' will bind to.\n",
+         hostname,
+         service_name);
+    memset (&hints, 0, sizeof(struct addrinfo));
+    if (disablev6)
+      hints.ai_family = AF_INET;
+    hints.ai_protocol = IPPROTO_TCP;
+    if ((0 != (ret = getaddrinfo (hostname, NULL, &hints, &res))) ||
+        (NULL == res))
     {
-      if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg,
-                                                             service_name,
-                                                             "START_ON_DEMAND"))
-        LOG(GNUNET_ERROR_TYPE_ERROR,
-            _(
-              "Have neither PORT nor UNIXPATH for service `%s', but one is required\n"),
-            service_name);
-      GNUNET_free_non_null(hostname);
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           _ ("Failed to resolve `%s': %s\n"),
+           hostname,
+           gai_strerror (ret));
+      GNUNET_free (hostname);
+      GNUNET_free_non_null (unixpath);
       return GNUNET_SYSERR;
     }
-  if (0 == port)
+    next = res;
+    i = 0;
+    while (NULL != (pos = next))
     {
-      saddrs = GNUNET_new_array(2, struct sockaddr *);
-      saddrlens = GNUNET_new_array(2, socklen_t);
-      add_unixpath(saddrs, saddrlens, unixpath, abstract);
-      GNUNET_free_non_null(unixpath);
-      GNUNET_free_non_null(hostname);
-      *addrs = saddrs;
-      *addr_lens = saddrlens;
-      return 1;
+      next = pos->ai_next;
+      if ((disablev6) && (pos->ai_family == AF_INET6))
+        continue;
+      i++;
     }
-
-  if (NULL != hostname)
+    if (0 == i)
     {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Resolving `%s' since that is where `%s' will bind to.\n",
-          hostname,
-          service_name);
-      memset(&hints, 0, sizeof(struct addrinfo));
-      if (disablev6)
-        hints.ai_family = AF_INET;
-      hints.ai_protocol = IPPROTO_TCP;
-      if ((0 != (ret = getaddrinfo(hostname, NULL, &hints, &res))) ||
-          (NULL == res))
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR,
-              _("Failed to resolve `%s': %s\n"),
-              hostname,
-              gai_strerror(ret));
-          GNUNET_free(hostname);
-          GNUNET_free_non_null(unixpath);
-          return GNUNET_SYSERR;
-        }
-      next = res;
-      i = 0;
-      while (NULL != (pos = next))
-        {
-          next = pos->ai_next;
-          if ((disablev6) && (pos->ai_family == AF_INET6))
-            continue;
-          i++;
-        }
-      if (0 == i)
-        {
-          LOG(GNUNET_ERROR_TYPE_ERROR,
-              _("Failed to find %saddress for `%s'.\n"),
-              disablev6 ? "IPv4 " : "",
-              hostname);
-          freeaddrinfo(res);
-          GNUNET_free(hostname);
-          GNUNET_free_non_null(unixpath);
-          return GNUNET_SYSERR;
-        }
-      resi = i;
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           _ ("Failed to find %saddress for `%s'.\n"),
+           disablev6 ? "IPv4 " : "",
+           hostname);
+      freeaddrinfo (res);
+      GNUNET_free (hostname);
+      GNUNET_free_non_null (unixpath);
+      return GNUNET_SYSERR;
+    }
+    resi = i;
+    if (NULL != unixpath)
+      resi++;
+    saddrs = GNUNET_new_array (resi + 1, struct sockaddr *);
+    saddrlens = GNUNET_new_array (resi + 1, socklen_t);
+    i = 0;
+    if (NULL != unixpath)
+    {
+      add_unixpath (saddrs, saddrlens, unixpath, abstract);
+      i++;
+    }
+    next = res;
+    while (NULL != (pos = next))
+    {
+      next = pos->ai_next;
+      if ((disablev6) && (AF_INET6 == pos->ai_family))
+        continue;
+      if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol))
+        continue;     /* not TCP */
+      if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype))
+        continue;     /* huh? */
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Service `%s' will bind to `%s'\n",
+           service_name,
+           GNUNET_a2s (pos->ai_addr, pos->ai_addrlen));
+      if (AF_INET == pos->ai_family)
+      {
+        GNUNET_assert (sizeof(struct sockaddr_in) == pos->ai_addrlen);
+        saddrlens[i] = pos->ai_addrlen;
+        saddrs[i] = GNUNET_malloc (saddrlens[i]);
+        GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
+        ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
+      }
+      else
+      {
+        GNUNET_assert (AF_INET6 == pos->ai_family);
+        GNUNET_assert (sizeof(struct sockaddr_in6) == pos->ai_addrlen);
+        saddrlens[i] = pos->ai_addrlen;
+        saddrs[i] = GNUNET_malloc (saddrlens[i]);
+        GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
+        ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
+      }
+      i++;
+    }
+    GNUNET_free (hostname);
+    freeaddrinfo (res);
+    resi = i;
+  }
+  else
+  {
+    /* will bind against everything, just set port */
+    if (disablev6)
+    {
+      /* V4-only */
+      resi = 1;
       if (NULL != unixpath)
         resi++;
-      saddrs = GNUNET_new_array(resi + 1, struct sockaddr *);
-      saddrlens = GNUNET_new_array(resi + 1, socklen_t);
       i = 0;
+      saddrs = GNUNET_new_array (resi + 1, struct sockaddr *);
+      saddrlens = GNUNET_new_array (resi + 1, socklen_t);
       if (NULL != unixpath)
-        {
-          add_unixpath(saddrs, saddrlens, unixpath, abstract);
-          i++;
-        }
-      next = res;
-      while (NULL != (pos = next))
-        {
-          next = pos->ai_next;
-          if ((disablev6) && (AF_INET6 == pos->ai_family))
-            continue;
-          if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol))
-            continue; /* not TCP */
-          if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype))
-            continue; /* huh? */
-          LOG(GNUNET_ERROR_TYPE_DEBUG,
-              "Service `%s' will bind to `%s'\n",
-              service_name,
-              GNUNET_a2s(pos->ai_addr, pos->ai_addrlen));
-          if (AF_INET == pos->ai_family)
-            {
-              GNUNET_assert(sizeof(struct sockaddr_in) == pos->ai_addrlen);
-              saddrlens[i] = pos->ai_addrlen;
-              saddrs[i] = GNUNET_malloc(saddrlens[i]);
-              GNUNET_memcpy(saddrs[i], pos->ai_addr, saddrlens[i]);
-              ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port);
-            }
-          else
-            {
-              GNUNET_assert(AF_INET6 == pos->ai_family);
-              GNUNET_assert(sizeof(struct sockaddr_in6) == pos->ai_addrlen);
-              saddrlens[i] = pos->ai_addrlen;
-              saddrs[i] = GNUNET_malloc(saddrlens[i]);
-              GNUNET_memcpy(saddrs[i], pos->ai_addr, saddrlens[i]);
-              ((struct sockaddr_in6 *)saddrs[i])->sin6_port = htons(port);
-            }
-          i++;
-        }
-      GNUNET_free(hostname);
-      freeaddrinfo(res);
-      resi = i;
-    }
-  else
-    {
-      /* will bind against everything, just set port */
-      if (disablev6)
-        {
-          /* V4-only */
-          resi = 1;
-          if (NULL != unixpath)
-            resi++;
-          i = 0;
-          saddrs = GNUNET_new_array(resi + 1, struct sockaddr *);
-          saddrlens = GNUNET_new_array(resi + 1, socklen_t);
-          if (NULL != unixpath)
-            {
-              add_unixpath(saddrs, saddrlens, unixpath, abstract);
-              i++;
-            }
-          saddrlens[i] = sizeof(struct sockaddr_in);
-          saddrs[i] = GNUNET_malloc(saddrlens[i]);
+      {
+        add_unixpath (saddrs, saddrlens, unixpath, abstract);
+        i++;
+      }
+      saddrlens[i] = sizeof(struct sockaddr_in);
+      saddrs[i] = GNUNET_malloc (saddrlens[i]);
 #if HAVE_SOCKADDR_IN_SIN_LEN
-          ((struct sockaddr_in *)saddrs[i])->sin_len = saddrlens[i];
+      ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[i];
 #endif
-          ((struct sockaddr_in *)saddrs[i])->sin_family = AF_INET;
-          ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port);
-        }
-      else
-        {
-          /* dual stack */
-          resi = 2;
-          if (NULL != unixpath)
-            resi++;
-          saddrs = GNUNET_new_array(resi + 1, struct sockaddr *);
-          saddrlens = GNUNET_new_array(resi + 1, socklen_t);
-          i = 0;
-          if (NULL != unixpath)
-            {
-              add_unixpath(saddrs, saddrlens, unixpath, abstract);
-              i++;
-            }
-          saddrlens[i] = sizeof(struct sockaddr_in6);
-          saddrs[i] = GNUNET_malloc(saddrlens[i]);
+      ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
+      ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
+    }
+    else
+    {
+      /* dual stack */
+      resi = 2;
+      if (NULL != unixpath)
+        resi++;
+      saddrs = GNUNET_new_array (resi + 1, struct sockaddr *);
+      saddrlens = GNUNET_new_array (resi + 1, socklen_t);
+      i = 0;
+      if (NULL != unixpath)
+      {
+        add_unixpath (saddrs, saddrlens, unixpath, abstract);
+        i++;
+      }
+      saddrlens[i] = sizeof(struct sockaddr_in6);
+      saddrs[i] = GNUNET_malloc (saddrlens[i]);
 #if HAVE_SOCKADDR_IN_SIN_LEN
-          ((struct sockaddr_in6 *)saddrs[i])->sin6_len = saddrlens[0];
+      ((struct sockaddr_in6 *) saddrs[i])->sin6_len = saddrlens[0];
 #endif
-          ((struct sockaddr_in6 *)saddrs[i])->sin6_family = AF_INET6;
-          ((struct sockaddr_in6 *)saddrs[i])->sin6_port = htons(port);
-          i++;
-          saddrlens[i] = sizeof(struct sockaddr_in);
-          saddrs[i] = GNUNET_malloc(saddrlens[i]);
+      ((struct sockaddr_in6 *) saddrs[i])->sin6_family = AF_INET6;
+      ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
+      i++;
+      saddrlens[i] = sizeof(struct sockaddr_in);
+      saddrs[i] = GNUNET_malloc (saddrlens[i]);
 #if HAVE_SOCKADDR_IN_SIN_LEN
-          ((struct sockaddr_in *)saddrs[i])->sin_len = saddrlens[1];
+      ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[1];
 #endif
-          ((struct sockaddr_in *)saddrs[i])->sin_family = AF_INET;
-          ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port);
-        }
+      ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
+      ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
     }
-  GNUNET_free_non_null(unixpath);
+  }
+  GNUNET_free_non_null (unixpath);
   *addrs = saddrs;
   *addr_lens = saddrlens;
   return resi;
@@ -670,19 +682,19 @@ get_server_addresses(const char *service_name,
  * @return NULL if it was not found
  */
 static void
-signal_result(struct GNUNET_SERVICE_Client *client,
-              const char *name,
-              uint64_t request_id,
-              enum GNUNET_ARM_Result result)
+signal_result (struct GNUNET_SERVICE_Client *client,
+               const char *name,
+               uint64_t request_id,
+               enum GNUNET_ARM_Result result)
 {
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_ARM_ResultMessage *msg;
 
-  (void)name;
-  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_ARM_RESULT);
-  msg->result = htonl(result);
-  msg->arm_msg.request_id = GNUNET_htonll(request_id);
-  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client), env);
+  (void) name;
+  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_ARM_RESULT);
+  msg->result = htonl (result);
+  msg->arm_msg.request_id = GNUNET_htonll (request_id);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
 }
 
 
@@ -695,34 +707,34 @@ signal_result(struct GNUNET_SERVICE_Client *client,
  *                otherwise, send to all clients in the notifier
  */
 static void
-broadcast_status(const char *name,
-                 enum GNUNET_ARM_ServiceStatus status,
-                 struct GNUNET_SERVICE_Client *unicast)
+broadcast_status (const char *name,
+                  enum GNUNET_ARM_ServiceMonitorStatus status,
+                  struct GNUNET_SERVICE_Client *unicast)
 {
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_ARM_StatusMessage *msg;
   size_t namelen;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Sending status %u of service `%s' to client\n",
-             (unsigned int)status,
-             name);
-  namelen = strlen(name) + 1;
-  env = GNUNET_MQ_msg_extra(msg, namelen, GNUNET_MESSAGE_TYPE_ARM_STATUS);
-  msg->status = htonl((uint32_t)(status));
-  GNUNET_memcpy((char *)&msg[1], name, namelen);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending status %u of service `%s' to client\n",
+              (unsigned int) status,
+              name);
+  namelen = strlen (name) + 1;
+  env = GNUNET_MQ_msg_extra (msg, namelen, GNUNET_MESSAGE_TYPE_ARM_STATUS);
+  msg->status = htonl ((uint32_t) (status));
+  GNUNET_memcpy ((char *) &msg[1], name, namelen);
   if (NULL == unicast)
-    {
-      if (NULL != notifier)
-        GNUNET_notification_context_broadcast(notifier,
-                                              &msg->header,
-                                              GNUNET_YES);
-      GNUNET_MQ_discard(env);
-    }
+  {
+    if (NULL != notifier)
+      GNUNET_notification_context_broadcast (notifier,
+                                             &msg->header,
+                                             GNUNET_YES);
+    GNUNET_MQ_discard (env);
+  }
   else
-    {
-      GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(unicast), env);
-    }
+  {
+    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (unicast), env);
+  }
 }
 
 
@@ -735,9 +747,9 @@ broadcast_status(const char *name,
  *                   being started. 0 if starting was not requested.
  */
 static void
-start_process(struct ServiceList *sl,
-              struct GNUNET_SERVICE_Client *client,
-              uint64_t request_id)
+start_process (struct ServiceList *sl,
+               struct GNUNET_SERVICE_Client *client,
+               uint64_t request_id)
 {
   char *loprefix;
   char *options;
@@ -753,191 +765,192 @@ start_process(struct ServiceList *sl,
   lsocks = NULL;
   ls = 0;
   for (sli = sl->listen_head; NULL != sli; sli = sli->next)
+  {
+    GNUNET_array_append (lsocks,
+                         ls,
+                         GNUNET_NETWORK_get_fd (sli->listen_socket));
+    if (NULL != sli->accept_task)
     {
-      GNUNET_array_append(lsocks,
-                          ls,
-                          GNUNET_NETWORK_get_fd(sli->listen_socket));
-      if (NULL != sli->accept_task)
-        {
-          GNUNET_SCHEDULER_cancel(sli->accept_task);
-          sli->accept_task = NULL;
-        }
+      GNUNET_SCHEDULER_cancel (sli->accept_task);
+      sli->accept_task = NULL;
     }
+  }
 
-  GNUNET_array_append(lsocks, ls, -1);
+  GNUNET_array_append (lsocks, ls, -1);
 
   /* obtain configuration */
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                         sl->name,
-                                                         "PREFIX",
-                                                         &loprefix))
-    loprefix = GNUNET_strdup(prefix_command);
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                          sl->name,
+                                                          "PREFIX",
+                                                          &loprefix))
+    loprefix = GNUNET_strdup (prefix_command);
   else
-    loprefix = GNUNET_CONFIGURATION_expand_dollar(cfg, loprefix);
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                         sl->name,
-                                                         "OPTIONS",
-                                                         &options))
+    loprefix = GNUNET_CONFIGURATION_expand_dollar (cfg, loprefix);
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                          sl->name,
+                                                          "OPTIONS",
+                                                          &options))
     options = NULL;
   else
-    options = GNUNET_CONFIGURATION_expand_dollar(cfg, options);
+    options = GNUNET_CONFIGURATION_expand_dollar (cfg, options);
   {
     char *new_options;
     char *optpos;
     char *fin_options;
 
-    fin_options = GNUNET_strdup(final_option);
+    fin_options = GNUNET_strdup (final_option);
     /* replace '{}' with service name */
-    while (NULL != (optpos = strstr(fin_options, "{}")))
-      {
-        /* terminate string at opening parenthesis */
-        *optpos = 0;
-        GNUNET_asprintf(&new_options,
-                        "%s%s%s",
-                        fin_options,
-                        sl->name,
-                        optpos + 2);
-        GNUNET_free(fin_options);
-        fin_options = new_options;
-      }
+    while (NULL != (optpos = strstr (fin_options, "{}")))
+    {
+      /* terminate string at opening parenthesis */
+      *optpos = 0;
+      GNUNET_asprintf (&new_options,
+                       "%s%s%s",
+                       fin_options,
+                       sl->name,
+                       optpos + 2);
+      GNUNET_free (fin_options);
+      fin_options = new_options;
+    }
     if (NULL != options)
-      {
-        /* combine "fin_options" with "options" */
-        optpos = options;
-        GNUNET_asprintf(&options, "%s %s", fin_options, optpos);
-        GNUNET_free(fin_options);
-        GNUNET_free(optpos);
-      }
+    {
+      /* combine "fin_options" with "options" */
+      optpos = options;
+      GNUNET_asprintf (&options, "%s %s", fin_options, optpos);
+      GNUNET_free (fin_options);
+      GNUNET_free (optpos);
+    }
     else
-      {
-        /* only have "fin_options", use that */
-        options = fin_options;
-      }
+    {
+      /* only have "fin_options", use that */
+      options = fin_options;
+    }
   }
-  options = GNUNET_CONFIGURATION_expand_dollar(cfg, options);
-  use_debug = GNUNET_CONFIGURATION_get_value_yesno(cfg, sl->name, "DEBUG");
+  options = GNUNET_CONFIGURATION_expand_dollar (cfg, options);
+  use_debug = GNUNET_CONFIGURATION_get_value_yesno (cfg, sl->name, "DEBUG");
   {
     const char *service_type = NULL;
     const char *choices[] = { "GNUNET", "SIMPLE", NULL };
 
     is_simple_service = GNUNET_NO;
-    if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_choice(cfg,
-                                                            sl->name,
-                                                            "TYPE",
-                                                            choices,
-                                                            &service_type)) &&
-        (0 == strcasecmp(service_type, "SIMPLE")))
+    if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_choice (cfg,
+                                                             sl->name,
+                                                             "TYPE",
+                                                             choices,
+                                                             &service_type)) &&
+        (0 == strcasecmp (service_type, "SIMPLE")))
       is_simple_service = GNUNET_YES;
   }
 
-  GNUNET_assert(NULL == sl->proc);
+  GNUNET_assert (NULL == sl->proc);
   if (GNUNET_YES == is_simple_service)
-    {
-      /* A simple service will receive no GNUnet specific
-         command line options. */
-      binary = GNUNET_strdup(sl->binary);
-      binary = GNUNET_CONFIGURATION_expand_dollar(cfg, binary);
-      GNUNET_asprintf(&quotedbinary, "\"%s\"", sl->binary);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Starting simple service `%s' using binary `%s'\n",
-                 sl->name,
-                 sl->binary);
-      /* FIXME: dollar expansion should only be done outside
-       * of ''-quoted strings, escaping should be considered. */
-      if (NULL != options)
-        options = GNUNET_CONFIGURATION_expand_dollar(cfg, options);
-      sl->proc = GNUNET_OS_start_process_s(sl->pipe_control,
-                                           GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
-                                           lsocks,
-                                           loprefix,
-                                           quotedbinary,
-                                           options,
-                                           NULL);
-    }
+  {
+    /* A simple service will receive no GNUnet specific
+       command line options. */
+    binary = GNUNET_strdup (sl->binary);
+    binary = GNUNET_CONFIGURATION_expand_dollar (cfg, binary);
+    GNUNET_asprintf (&quotedbinary, "\"%s\"", sl->binary);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Starting simple service `%s' using binary `%s'\n",
+                sl->name,
+                sl->binary);
+    /* FIXME: dollar expansion should only be done outside
+     * of ''-quoted strings, escaping should be considered. */
+    if (NULL != options)
+      options = GNUNET_CONFIGURATION_expand_dollar (cfg, options);
+    sl->proc = GNUNET_OS_start_process_s (sl->pipe_control,
+                                          GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+                                          lsocks,
+                                          loprefix,
+                                          quotedbinary,
+                                          options,
+                                          NULL);
+  }
   else
+  {
+    /* actually start process */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Starting service `%s' using binary `%s' and configuration `%s'\n",
+                sl->name,
+                sl->binary,
+                sl->config);
+    binary = GNUNET_OS_get_libexec_binary_path (sl->binary);
+    GNUNET_asprintf (&quotedbinary, "\"%s\"", binary);
+
+    if (GNUNET_YES == use_debug)
     {
-      /* actually start process */
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Starting service `%s' using binary `%s' and configuration `%s'\n",
-                 sl->name,
-                 sl->binary,
-                 sl->config);
-      binary = GNUNET_OS_get_libexec_binary_path(sl->binary);
-      GNUNET_asprintf(&quotedbinary, "\"%s\"", binary);
-
-      if (GNUNET_YES == use_debug)
-        {
-          if (NULL == sl->config)
-            sl->proc = GNUNET_OS_start_process_s(sl->pipe_control,
-                                                 GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
-                                                 lsocks,
-                                                 loprefix,
-                                                 quotedbinary,
-                                                 "-L",
-                                                 "DEBUG",
-                                                 options,
-                                                 NULL);
-          else
-            sl->proc = GNUNET_OS_start_process_s(sl->pipe_control,
-                                                 GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
-                                                 lsocks,
-                                                 loprefix,
-                                                 quotedbinary,
-                                                 "-c",
-                                                 sl->config,
-                                                 "-L",
-                                                 "DEBUG",
-                                                 options,
-                                                 NULL);
-        }
+      if (NULL == sl->config)
+        sl->proc = GNUNET_OS_start_process_s (sl->pipe_control,
+                                              GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+                                              lsocks,
+                                              loprefix,
+                                              quotedbinary,
+                                              "-L",
+                                              "DEBUG",
+                                              options,
+                                              NULL);
       else
-        {
-          if (NULL == sl->config)
-            sl->proc = GNUNET_OS_start_process_s(sl->pipe_control,
-                                                 GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
-                                                 lsocks,
-                                                 loprefix,
-                                                 quotedbinary,
-                                                 options,
-                                                 NULL);
-          else
-            sl->proc = GNUNET_OS_start_process_s(sl->pipe_control,
-                                                 GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
-                                                 lsocks,
-                                                 loprefix,
-                                                 quotedbinary,
-                                                 "-c",
-                                                 sl->config,
-                                                 options,
-                                                 NULL);
-        }
+        sl->proc = GNUNET_OS_start_process_s (sl->pipe_control,
+                                              GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+                                              lsocks,
+                                              loprefix,
+                                              quotedbinary,
+                                              "-c",
+                                              sl->config,
+                                              "-L",
+                                              "DEBUG",
+                                              options,
+                                              NULL);
     }
-  GNUNET_free(binary);
-  GNUNET_free(quotedbinary);
-  if (NULL == sl->proc)
+    else
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Failed to start service `%s'\n"),
-                 sl->name);
-      if (client)
-        signal_result(client,
-                      sl->name,
-                      request_id,
-                      GNUNET_ARM_RESULT_START_FAILED);
+      if (NULL == sl->config)
+        sl->proc = GNUNET_OS_start_process_s (sl->pipe_control,
+                                              GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+                                              lsocks,
+                                              loprefix,
+                                              quotedbinary,
+                                              options,
+                                              NULL);
+      else
+        sl->proc = GNUNET_OS_start_process_s (sl->pipe_control,
+                                              GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+                                              lsocks,
+                                              loprefix,
+                                              quotedbinary,
+                                              "-c",
+                                              sl->config,
+                                              options,
+                                              NULL);
     }
+  }
+  GNUNET_free (binary);
+  GNUNET_free (quotedbinary);
+  sl->last_started_at = GNUNET_TIME_absolute_get ();
+  if (NULL == sl->proc)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Failed to start service `%s'\n"),
+                sl->name);
+    if (client)
+      signal_result (client,
+                     sl->name,
+                     request_id,
+                     GNUNET_ARM_RESULT_START_FAILED);
+  }
   else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 _("Starting service `%s'\n"),
-                 sl->name);
-      broadcast_status(sl->name, GNUNET_ARM_SERVICE_STARTING, NULL);
-      if (client)
-        signal_result(client, sl->name, request_id, GNUNET_ARM_RESULT_STARTING);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _ ("Starting service `%s'\n"),
+                sl->name);
+    broadcast_status (sl->name, GNUNET_ARM_SERVICE_STARTING, NULL);
+    if (client)
+      signal_result (client, sl->name, request_id, GNUNET_ARM_RESULT_STARTING);
+  }
   /* clean up */
-  GNUNET_free(loprefix);
-  GNUNET_free(options);
-  GNUNET_array_grow(lsocks, ls, 0);
+  GNUNET_free (loprefix);
+  GNUNET_free (options);
+  GNUNET_array_grow (lsocks, ls, 0);
 }
 
 
@@ -949,17 +962,17 @@ start_process(struct ServiceList *sl,
  * @return NULL if it was not found
  */
 static struct ServiceList *
-find_service(const char *name)
+find_service (const char *name)
 {
   struct ServiceList *sl;
 
   sl = running_head;
   while (sl != NULL)
-    {
-      if (0 == strcasecmp(sl->name, name))
-        return sl;
-      sl = sl->next;
-    }
+  {
+    if (0 == strcasecmp (sl->name, name))
+      return sl;
+    sl = sl->next;
+  }
   return NULL;
 }
 
@@ -971,14 +984,14 @@ find_service(const char *name)
  * @param cls callback data, `struct ServiceListeningInfo` describing a listen socket
  */
 static void
-accept_connection(void *cls)
+accept_connection (void *cls)
 {
   struct ServiceListeningInfo *sli = cls;
   struct ServiceList *sl = sli->sl;
 
   sli->accept_task = NULL;
-  GNUNET_assert(GNUNET_NO == in_shutdown);
-  start_process(sl, NULL, 0);
+  GNUNET_assert (GNUNET_NO == in_shutdown);
+  start_process (sl, NULL, 0);
 }
 
 
@@ -991,9 +1004,9 @@ accept_connection(void *cls)
  * @param sl service entry for the service in question
  */
 static void
-create_listen_socket(struct sockaddr *sa,
-                     socklen_t addr_len,
-                     struct ServiceList *sl)
+create_listen_socket (struct sockaddr *sa,
+                      socklen_t addr_len,
+                      struct ServiceList *sl)
 {
   static int on = 1;
   struct GNUNET_NETWORK_Handle *sock;
@@ -1003,107 +1016,107 @@ create_listen_socket(struct sockaddr *sa,
   int match_gid;
 
   switch (sa->sa_family)
-    {
-    case AF_INET:
-      sock = GNUNET_NETWORK_socket_create(PF_INET, SOCK_STREAM, 0);
-      break;
-
-    case AF_INET6:
-      sock = GNUNET_NETWORK_socket_create(PF_INET6, SOCK_STREAM, 0);
-      break;
-
-    case AF_UNIX:
-      if (0 == strcmp(GNUNET_a2s(sa, addr_len),
-                      "@")) /* Do not bind to blank UNIX path! */
-        return;
-      sock = GNUNET_NETWORK_socket_create(PF_UNIX, SOCK_STREAM, 0);
-      break;
-
-    default:
-      GNUNET_break(0);
-      sock = NULL;
-      errno = EAFNOSUPPORT;
-      break;
-    }
-  if (NULL == sock)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Unable to create socket for service `%s': %s\n"),
-                 sl->name,
-                 strerror(errno));
-      GNUNET_free(sa);
+  {
+  case AF_INET:
+    sock = GNUNET_NETWORK_socket_create (PF_INET, SOCK_STREAM, 0);
+    break;
+
+  case AF_INET6:
+    sock = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0);
+    break;
+
+  case AF_UNIX:
+    if (0 == strcmp (GNUNET_a2s (sa, addr_len),
+                     "@"))  /* Do not bind to blank UNIX path! */
       return;
-    }
-  if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt(sock,
-                                                    SOL_SOCKET,
-                                                    SO_REUSEADDR,
-                                                    &on,
-                                                    sizeof(on)))
-    GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                        "setsockopt");
+    sock = GNUNET_NETWORK_socket_create (PF_UNIX, SOCK_STREAM, 0);
+    break;
+
+  default:
+    GNUNET_break (0);
+    sock = NULL;
+    errno = EAFNOSUPPORT;
+    break;
+  }
+  if (NULL == sock)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Unable to create socket for service `%s': %s\n"),
+                sl->name,
+                strerror (errno));
+    GNUNET_free (sa);
+    return;
+  }
+  if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (sock,
+                                                     SOL_SOCKET,
+                                                     SO_REUSEADDR,
+                                                     &on,
+                                                     sizeof(on)))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                         "setsockopt");
 #ifdef IPV6_V6ONLY
   if ((sa->sa_family == AF_INET6) &&
-      (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt(sock,
-                                                     IPPROTO_IPV6,
-                                                     IPV6_V6ONLY,
-                                                     &on,
-                                                     sizeof(on))))
-    GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                        "setsockopt");
+      (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (sock,
+                                                      IPPROTO_IPV6,
+                                                      IPV6_V6ONLY,
+                                                      &on,
+                                                      sizeof(on))))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                         "setsockopt");
 #endif
   if (AF_UNIX == sa->sa_family)
-    GNUNET_NETWORK_unix_precheck((struct sockaddr_un *)sa);
+    GNUNET_NETWORK_unix_precheck ((struct sockaddr_un *) sa);
   if (GNUNET_OK !=
-      GNUNET_NETWORK_socket_bind(sock, (const struct sockaddr *)sa, addr_len))
-    {
-      GNUNET_log(
-        GNUNET_ERROR_TYPE_WARNING,
-        _(
-          "Unable to bind listening socket for service `%s' to address `%s': %s\n"),
-        sl->name,
-        GNUNET_a2s(sa, addr_len),
-        strerror(errno));
-      GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(sock));
-      GNUNET_free(sa);
-      return;
-    }
+      GNUNET_NETWORK_socket_bind (sock, (const struct sockaddr *) sa, addr_len))
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_WARNING,
+      _ (
+        "Unable to bind listening socket for service `%s' to address `%s': %s\n"),
+      sl->name,
+      GNUNET_a2s (sa, addr_len),
+      strerror (errno));
+    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
+    GNUNET_free (sa);
+    return;
+  }
   if ((AF_UNIX == sa->sa_family)
 #ifdef LINUX
       /* Permission settings are not required when abstract sockets are used */
-      && ('\0' != ((const struct sockaddr_un *)sa)->sun_path[0])
+      && ('\0' != ((const struct sockaddr_un *) sa)->sun_path[0])
 #endif
       )
-    {
-      match_uid =
-        GNUNET_CONFIGURATION_get_value_yesno(cfg, sl->name, "UNIX_MATCH_UID");
-      match_gid =
-        GNUNET_CONFIGURATION_get_value_yesno(cfg, sl->name, "UNIX_MATCH_GID");
-      GNUNET_DISK_fix_permissions(((const struct sockaddr_un *)sa)->sun_path,
-                                  match_uid,
-                                  match_gid);
-    }
-  if (GNUNET_OK != GNUNET_NETWORK_socket_listen(sock, 5))
-    {
-      GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "listen");
-      GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(sock));
-      GNUNET_free(sa);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             _("ARM now monitors connections to service `%s' at `%s'\n"),
-             sl->name,
-             GNUNET_a2s(sa, addr_len));
-  sli = GNUNET_new(struct ServiceListeningInfo);
+  {
+    match_uid =
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, sl->name, "UNIX_MATCH_UID");
+    match_gid =
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, sl->name, "UNIX_MATCH_GID");
+    GNUNET_DISK_fix_permissions (((const struct sockaddr_un *) sa)->sun_path,
+                                 match_uid,
+                                 match_gid);
+  }
+  if (GNUNET_OK != GNUNET_NETWORK_socket_listen (sock, 5))
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "listen");
+    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
+    GNUNET_free (sa);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _ ("ARM now monitors connections to service `%s' at `%s'\n"),
+              sl->name,
+              GNUNET_a2s (sa, addr_len));
+  sli = GNUNET_new (struct ServiceListeningInfo);
   sli->service_addr = sa;
   sli->service_addr_len = addr_len;
   sli->listen_socket = sock;
   sli->sl = sl;
   sli->accept_task =
-    GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
-                                  sock,
-                                  &accept_connection,
-                                  sli);
-  GNUNET_CONTAINER_DLL_insert(sl->listen_head, sl->listen_tail, sli);
+    GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                   sock,
+                                   &accept_connection,
+                                   sli);
+  GNUNET_CONTAINER_DLL_insert (sl->listen_head, sl->listen_tail, sli);
 }
 
 
@@ -1114,15 +1127,15 @@ create_listen_socket(struct sockaddr *sa,
  * @param sl entry to free
  */
 static void
-free_service(struct ServiceList *sl)
+free_service (struct ServiceList *sl)
 {
-  GNUNET_assert(GNUNET_YES == in_shutdown);
-  GNUNET_CONTAINER_DLL_remove(running_head, running_tail, sl);
-  GNUNET_assert(NULL == sl->listen_head);
-  GNUNET_free_non_null(sl->config);
-  GNUNET_free_non_null(sl->binary);
-  GNUNET_free(sl->name);
-  GNUNET_free(sl);
+  GNUNET_assert (GNUNET_YES == in_shutdown);
+  GNUNET_CONTAINER_DLL_remove (running_head, running_tail, sl);
+  GNUNET_assert (NULL == sl->listen_head);
+  GNUNET_free_non_null (sl->config);
+  GNUNET_free_non_null (sl->binary);
+  GNUNET_free (sl->name);
+  GNUNET_free (sl);
 }
 
 
@@ -1135,10 +1148,10 @@ free_service(struct ServiceList *sl)
  *         #GNUNET_SYSERR to close it (signal serious error)
  */
 static int
-check_start(void *cls, const struct GNUNET_ARM_Message *amsg)
+check_start (void *cls, const struct GNUNET_ARM_Message *amsg)
 {
-  (void)cls;
-  GNUNET_MQ_check_zero_termination(amsg);
+  (void) cls;
+  GNUNET_MQ_check_zero_termination (amsg);
   return GNUNET_OK;
 }
 
@@ -1150,43 +1163,43 @@ check_start(void *cls, const struct GNUNET_ARM_Message *amsg)
  * @param amsg the actual message
  */
 static void
-handle_start(void *cls, const struct GNUNET_ARM_Message *amsg)
+handle_start (void *cls, const struct GNUNET_ARM_Message *amsg)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   const char *servicename;
   struct ServiceList *sl;
   uint64_t request_id;
 
-  request_id = GNUNET_ntohll(amsg->request_id);
-  servicename = (const char *)&amsg[1];
-  GNUNET_SERVICE_client_continue(client);
+  request_id = GNUNET_ntohll (amsg->request_id);
+  servicename = (const char *) &amsg[1];
+  GNUNET_SERVICE_client_continue (client);
   if (GNUNET_YES == in_shutdown)
-    {
-      signal_result(client,
-                    servicename,
-                    request_id,
-                    GNUNET_ARM_RESULT_IN_SHUTDOWN);
-      return;
-    }
-  sl = find_service(servicename);
+  {
+    signal_result (client,
+                   servicename,
+                   request_id,
+                   GNUNET_ARM_RESULT_IN_SHUTDOWN);
+    return;
+  }
+  sl = find_service (servicename);
   if (NULL == sl)
-    {
-      signal_result(client,
-                    servicename,
-                    request_id,
-                    GNUNET_ARM_RESULT_IS_NOT_KNOWN);
-      return;
-    }
+  {
+    signal_result (client,
+                   servicename,
+                   request_id,
+                   GNUNET_ARM_RESULT_IS_NOT_KNOWN);
+    return;
+  }
   sl->force_start = GNUNET_YES;
   if (NULL != sl->proc)
-    {
-      signal_result(client,
-                    servicename,
-                    request_id,
-                    GNUNET_ARM_RESULT_IS_STARTED_ALREADY);
-      return;
-    }
-  start_process(sl, client, request_id);
+  {
+    signal_result (client,
+                   servicename,
+                   request_id,
+                   GNUNET_ARM_RESULT_IS_STARTED_ALREADY);
+    return;
+  }
+  start_process (sl, client, request_id);
 }
 
 
@@ -1196,11 +1209,11 @@ handle_start(void *cls, const struct GNUNET_ARM_Message *amsg)
  * @param cls closure (refers to service)
  */
 static void
-trigger_shutdown(void *cls)
+trigger_shutdown (void *cls)
 {
-  (void)cls;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Triggering shutdown\n");
-  GNUNET_SCHEDULER_shutdown();
+  (void) cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Triggering shutdown\n");
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -1213,10 +1226,10 @@ trigger_shutdown(void *cls)
  *         #GNUNET_SYSERR to close it (signal serious error)
  */
 static int
-check_stop(void *cls, const struct GNUNET_ARM_Message *amsg)
+check_stop (void *cls, const struct GNUNET_ARM_Message *amsg)
 {
-  (void)cls;
-  GNUNET_MQ_check_zero_termination(amsg);
+  (void) cls;
+  GNUNET_MQ_check_zero_termination (amsg);
   return GNUNET_OK;
 }
 
@@ -1228,128 +1241,184 @@ check_stop(void *cls, const struct GNUNET_ARM_Message *amsg)
  * @param amsg the actual message
  */
 static void
-handle_stop(void *cls, const struct GNUNET_ARM_Message *amsg)
+handle_stop (void *cls, const struct GNUNET_ARM_Message *amsg)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   struct ServiceList *sl;
   const char *servicename;
   uint64_t request_id;
 
-  request_id = GNUNET_ntohll(amsg->request_id);
-  servicename = (const char *)&amsg[1];
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             _("Preparing to stop `%s'\n"),
-             servicename);
-  GNUNET_SERVICE_client_continue(client);
-  if (0 == strcasecmp(servicename, "arm"))
-    {
-      broadcast_status(servicename, GNUNET_ARM_SERVICE_STOPPING, NULL);
-      signal_result(client, servicename, request_id, GNUNET_ARM_RESULT_STOPPING);
-      GNUNET_SERVICE_client_persist(client);
-      GNUNET_SCHEDULER_add_now(&trigger_shutdown, NULL);
-      return;
-    }
-  sl = find_service(servicename);
+  request_id = GNUNET_ntohll (amsg->request_id);
+  servicename = (const char *) &amsg[1];
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _ ("Preparing to stop `%s'\n"),
+              servicename);
+  GNUNET_SERVICE_client_continue (client);
+  if (0 == strcasecmp (servicename, "arm"))
+  {
+    broadcast_status (servicename, GNUNET_ARM_SERVICE_STOPPING, NULL);
+    signal_result (client, servicename, request_id, GNUNET_ARM_RESULT_STOPPING);
+    GNUNET_SERVICE_client_persist (client);
+    GNUNET_SCHEDULER_add_now (&trigger_shutdown, NULL);
+    return;
+  }
+  sl = find_service (servicename);
   if (NULL == sl)
-    {
-      signal_result(client,
-                    servicename,
-                    request_id,
-                    GNUNET_ARM_RESULT_IS_NOT_KNOWN);
-      return;
-    }
+  {
+    signal_result (client,
+                   servicename,
+                   request_id,
+                   GNUNET_ARM_RESULT_IS_NOT_KNOWN);
+    return;
+  }
   sl->force_start = GNUNET_NO;
   if (GNUNET_YES == in_shutdown)
-    {
-      /* shutdown in progress */
-      signal_result(client,
-                    servicename,
-                    request_id,
-                    GNUNET_ARM_RESULT_IN_SHUTDOWN);
-      return;
-    }
+  {
+    /* shutdown in progress */
+    signal_result (client,
+                   servicename,
+                   request_id,
+                   GNUNET_ARM_RESULT_IN_SHUTDOWN);
+    return;
+  }
   if (NULL != sl->killing_client)
-    {
-      /* killing already in progress */
-      signal_result(client,
-                    servicename,
-                    request_id,
-                    GNUNET_ARM_RESULT_IS_STOPPING_ALREADY);
-      return;
-    }
+  {
+    /* killing already in progress */
+    signal_result (client,
+                   servicename,
+                   request_id,
+                   GNUNET_ARM_RESULT_IS_STOPPING_ALREADY);
+    return;
+  }
   if (NULL == sl->proc)
-    {
-      /* process is down */
-      signal_result(client,
-                    servicename,
-                    request_id,
-                    GNUNET_ARM_RESULT_IS_STOPPED_ALREADY);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Sending kill signal to service `%s', waiting for process to die.\n",
-             servicename);
-  broadcast_status(servicename, GNUNET_ARM_SERVICE_STOPPING, NULL);
+  {
+    /* process is down */
+    signal_result (client,
+                   servicename,
+                   request_id,
+                   GNUNET_ARM_RESULT_IS_STOPPED_ALREADY);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending kill signal to service `%s', waiting for process to die.\n",
+              servicename);
+  broadcast_status (servicename, GNUNET_ARM_SERVICE_STOPPING, NULL);
   /* no signal_start - only when it's STOPPED */
-  sl->killed_at = GNUNET_TIME_absolute_get();
-  if (0 != GNUNET_OS_process_kill(sl->proc, GNUNET_TERM_SIG))
-    GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill");
+  sl->killed_at = GNUNET_TIME_absolute_get ();
+  if (0 != GNUNET_OS_process_kill (sl->proc, GNUNET_TERM_SIG))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
   sl->killing_client = client;
   sl->killing_client_request_id = request_id;
 }
 
 
 /**
+ * Write a string to a string pool.
+ *
+ * @param pool_start pointer to the start of the string pool
+ * @param pool_size size of the string pool
+ * @param[in,out] pool_pos current position index in the string pool,
+ *                will be updated
+ * @param str string to write to the string pool
+ * @returns GNUNET_OK if the string fits into the pool,
+ *          GNUNET_SYSERR otherwise
+ */
+static int
+pool_write (char *pool_start, size_t pool_size, size_t *pool_pos, char *str)
+{
+  size_t next_pos = (*pool_pos) + strlen (str) + 1;
+
+  if (next_pos > pool_size)
+    return GNUNET_SYSERR;
+  memcpy (pool_start + *pool_pos, str, strlen (str) + 1);
+  *pool_pos = next_pos;
+  return GNUNET_OK;
+}
+
+/**
  * Handle LIST-message.
  *
  * @param cls identification of the client
  * @param message the actual message
  */
 static void
-handle_list(void *cls, const struct GNUNET_ARM_Message *request)
+handle_list (void *cls, const struct GNUNET_ARM_Message *request)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_ARM_ListResultMessage *msg;
-  size_t string_list_size;
+  size_t extra_size;
   struct ServiceList *sl;
   uint16_t count;
-  char *pos;
+  size_t pool_size;
+  size_t pool_pos;
+  char *pool_start;
+  struct GNUNET_ARM_ServiceInfoMessage *ssm;
 
-  GNUNET_break(0 == ntohl(request->reserved));
+  GNUNET_break_op (0 == ntohl (request->reserved));
   count = 0;
-  string_list_size = 0;
+  pool_size = 0;
 
-  /* first count the running processes get their name's size */
+  /* Do one pass over the list to compute the number of services
+   * and the string pool size */
   for (sl = running_head; NULL != sl; sl = sl->next)
-    {
-      if (NULL != sl->proc)
-        {
-          string_list_size += strlen(sl->name);
-          string_list_size += strlen(sl->binary);
-          string_list_size += 4;
-          count++;
-        }
-    }
+  {
+    pool_size += strlen (sl->name) + 1;
+    pool_size += strlen (sl->binary) + 1;
+    count++;
+  }
 
-  env = GNUNET_MQ_msg_extra(msg,
-                            string_list_size,
-                            GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT);
+  extra_size = pool_size + (count * sizeof (struct
+                                            GNUNET_ARM_ServiceInfoMessage));
+  env = GNUNET_MQ_msg_extra (msg,
+                             extra_size,
+                             GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT);
   msg->arm_msg.request_id = request->request_id;
-  msg->count = htons(count);
+  msg->count = htons (count);
+
+  ssm = (struct GNUNET_ARM_ServiceInfoMessage *) &msg[1];
+  pool_start = (char *) (ssm + count);
+  pool_pos = 0;
 
-  pos = (char *)&msg[1];
   for (sl = running_head; NULL != sl; sl = sl->next)
+  {
+    ssm->name_index = htons ((uint16_t) pool_pos);
+    GNUNET_assert (GNUNET_OK == pool_write (pool_start, pool_size, &pool_pos,
+                                            sl->name));
+    ssm->binary_index = htons ((uint16_t) pool_pos);
+    GNUNET_assert (GNUNET_OK == pool_write (pool_start, pool_size, &pool_pos,
+                                            sl->binary));
+    if (NULL == sl->proc)
     {
-      if (NULL != sl->proc)
-        {
-          size_t s = strlen(sl->name) + strlen(sl->binary) + 4;
-          GNUNET_snprintf(pos, s, "%s (%s)", sl->name, sl->binary);
-          pos += s;
-        }
+      if (0 == sl->last_started_at.abs_value_us)
+      {
+        /* Process never started */
+        ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_STOPPED);
+      }
+      else if (0 == sl->last_exit_status)
+      {
+        ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_FINISHED);
+      }
+      else
+      {
+        ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_FAILED);
+        ssm->last_exit_status = htons (sl->last_exit_status);
+      }
+    }
+    else if ((NULL != sl->killing_client) || (GNUNET_YES == in_shutdown))
+    {
+      ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_STOPPING);
+    }
+    else
+    {
+      ssm->status = htonl (GNUNET_ARM_SERVICE_STATUS_STARTED);
     }
-  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client), env);
-  GNUNET_SERVICE_client_continue(client);
+    ssm->last_started_at = GNUNET_TIME_absolute_hton (sl->last_started_at);
+    ssm->restart_at = GNUNET_TIME_absolute_hton (sl->restart_at);
+    ssm++;
+  }
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -1360,16 +1429,16 @@ handle_list(void *cls, const struct GNUNET_ARM_Message *request)
  * @param message the actual message
  */
 static void
-handle_test(void *cls, const struct GNUNET_MessageHeader *message)
+handle_test (void *cls, const struct GNUNET_MessageHeader *message)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_MessageHeader *msg;
 
-  (void)message;
-  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_ARM_TEST);
-  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client), env);
-  GNUNET_SERVICE_client_continue(client);
+  (void) message;
+  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_ARM_TEST);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -1378,24 +1447,24 @@ handle_test(void *cls, const struct GNUNET_MessageHeader *message)
  * tasks, signal handler and the server.
  */
 static void
-do_shutdown()
+do_shutdown ()
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Last shutdown phase\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Last shutdown phase\n");
   if (NULL != notifier)
-    {
-      GNUNET_notification_context_destroy(notifier);
-      notifier = NULL;
-    }
+  {
+    GNUNET_notification_context_destroy (notifier);
+    notifier = NULL;
+  }
   if (NULL != service)
-    {
-      GNUNET_SERVICE_shutdown(service);
-      service = NULL;
-    }
+  {
+    GNUNET_SERVICE_shutdown (service);
+    service = NULL;
+  }
   if (NULL != child_death_task)
-    {
-      GNUNET_SCHEDULER_cancel(child_death_task);
-      child_death_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (child_death_task);
+    child_death_task = NULL;
+  }
 }
 
 
@@ -1406,13 +1475,13 @@ do_shutdown()
  * @return number of active services found
  */
 static unsigned int
-list_count(struct ServiceList *running_head)
+list_count (struct ServiceList *running_head)
 {
   struct ServiceList *i;
   unsigned int res;
 
   for (res = 0, i = running_head; NULL != i; i = i->next, res++)
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s\n", i->name);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%s\n", i->name);
   return res;
 }
 
@@ -1423,61 +1492,61 @@ list_count(struct ServiceList *running_head)
  * @param cls closure, NULL if we need to self-restart
  */
 static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
 {
   struct ServiceList *pos;
   struct ServiceList *nxt;
   struct ServiceListeningInfo *sli;
 
-  (void)cls;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "First shutdown phase\n");
+  (void) cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "First shutdown phase\n");
   if (NULL != child_restart_task)
-    {
-      GNUNET_SCHEDULER_cancel(child_restart_task);
-      child_restart_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (child_restart_task);
+    child_restart_task = NULL;
+  }
   in_shutdown = GNUNET_YES;
   /* first, stop listening */
   for (pos = running_head; NULL != pos; pos = pos->next)
+  {
+    while (NULL != (sli = pos->listen_head))
     {
-      while (NULL != (sli = pos->listen_head))
-        {
-          GNUNET_CONTAINER_DLL_remove(pos->listen_head, pos->listen_tail, sli);
-          if (NULL != sli->accept_task)
-            {
-              GNUNET_SCHEDULER_cancel(sli->accept_task);
-              sli->accept_task = NULL;
-            }
-          GNUNET_break(GNUNET_OK ==
-                       GNUNET_NETWORK_socket_close(sli->listen_socket));
-          GNUNET_free(sli->service_addr);
-          GNUNET_free(sli);
-        }
+      GNUNET_CONTAINER_DLL_remove (pos->listen_head, pos->listen_tail, sli);
+      if (NULL != sli->accept_task)
+      {
+        GNUNET_SCHEDULER_cancel (sli->accept_task);
+        sli->accept_task = NULL;
+      }
+      GNUNET_break (GNUNET_OK ==
+                    GNUNET_NETWORK_socket_close (sli->listen_socket));
+      GNUNET_free (sli->service_addr);
+      GNUNET_free (sli);
     }
+  }
   /* then, shutdown all existing service processes */
   nxt = running_head;
   while (NULL != (pos = nxt))
+  {
+    nxt = pos->next;
+    if (NULL != pos->proc)
     {
-      nxt = pos->next;
-      if (NULL != pos->proc)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Stopping service `%s'\n", pos->name);
-          pos->killed_at = GNUNET_TIME_absolute_get();
-          if (0 != GNUNET_OS_process_kill(pos->proc, GNUNET_TERM_SIG))
-            GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill");
-        }
-      else
-        {
-          free_service(pos);
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Stopping service `%s'\n", pos->name);
+      pos->killed_at = GNUNET_TIME_absolute_get ();
+      if (0 != GNUNET_OS_process_kill (pos->proc, GNUNET_TERM_SIG))
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
     }
+    else
+    {
+      free_service (pos);
+    }
+  }
   /* finally, should all service processes be already gone, terminate for real */
   if (NULL == running_head)
-    do_shutdown();
+    do_shutdown ();
   else
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-               "Delaying shutdown, have %u childs still running\n",
-               list_count(running_head));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Delaying shutdown, have %u childs still running\n",
+                list_count (running_head));
 }
 
 
@@ -1487,73 +1556,73 @@ shutdown_task(void *cls)
  * @param cls closure, always NULL
  */
 static void
-delayed_restart_task(void *cls)
+delayed_restart_task (void *cls)
 
 {
   struct ServiceList *sl;
   struct GNUNET_TIME_Relative lowestRestartDelay;
   struct ServiceListeningInfo *sli;
 
-  (void)cls;
+  (void) cls;
   child_restart_task = NULL;
-  GNUNET_assert(GNUNET_NO == in_shutdown);
+  GNUNET_assert (GNUNET_NO == in_shutdown);
   lowestRestartDelay = GNUNET_TIME_UNIT_FOREVER_REL;
 
   /* check for services that need to be restarted due to
    * configuration changes or because the last restart failed */
   for (sl = running_head; NULL != sl; sl = sl->next)
+  {
+    if (NULL != sl->proc)
+      continue;
+    /* service is currently not running */
+    if (0 == GNUNET_TIME_absolute_get_remaining (sl->restart_at).rel_value_us)
     {
-      if (NULL != sl->proc)
-        continue;
-      /* service is currently not running */
-      if (0 == GNUNET_TIME_absolute_get_remaining(sl->restart_at).rel_value_us)
-        {
-          /* restart is now allowed */
-          if (sl->force_start)
-            {
-              /* process should run by default, start immediately */
-              GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                         _("Restarting service `%s'.\n"),
-                         sl->name);
-              start_process(sl, NULL, 0);
-            }
-          else
-            {
-              /* process is run on-demand, ensure it is re-started if there is demand */
-              for (sli = sl->listen_head; NULL != sli; sli = sli->next)
-                if (NULL == sli->accept_task)
-                  {
-                    /* accept was actually paused, so start it again */
-                    sli->accept_task =
-                      GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
-                                                    sli->listen_socket,
-                                                    &accept_connection,
-                                                    sli);
-                  }
-            }
-        }
+      /* restart is now allowed */
+      if (sl->force_start)
+      {
+        /* process should run by default, start immediately */
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                    _ ("Restarting service `%s'.\n"),
+                    sl->name);
+        start_process (sl, NULL, 0);
+      }
       else
-        {
-          /* update calculation for earliest time to reactivate a service */
-          lowestRestartDelay =
-            GNUNET_TIME_relative_min(lowestRestartDelay,
-                                     GNUNET_TIME_absolute_get_remaining(
-                                       sl->restart_at));
-        }
+      {
+        /* process is run on-demand, ensure it is re-started if there is demand */
+        for (sli = sl->listen_head; NULL != sli; sli = sli->next)
+          if (NULL == sli->accept_task)
+          {
+            /* accept was actually paused, so start it again */
+            sli->accept_task =
+              GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                             sli->listen_socket,
+                                             &accept_connection,
+                                             sli);
+          }
+      }
+    }
+    else
+    {
+      /* update calculation for earliest time to reactivate a service */
+      lowestRestartDelay =
+        GNUNET_TIME_relative_min (lowestRestartDelay,
+                                  GNUNET_TIME_absolute_get_remaining (
+                                    sl->restart_at));
     }
+  }
   if (lowestRestartDelay.rel_value_us !=
       GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Will restart process in %s\n",
-                 GNUNET_STRINGS_relative_time_to_string(lowestRestartDelay,
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Will restart process in %s\n",
+                GNUNET_STRINGS_relative_time_to_string (lowestRestartDelay,
                                                         GNUNET_YES));
-      child_restart_task =
-        GNUNET_SCHEDULER_add_delayed_with_priority(lowestRestartDelay,
-                                                   GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                                   &delayed_restart_task,
-                                                   NULL);
-    }
+    child_restart_task =
+      GNUNET_SCHEDULER_add_delayed_with_priority (lowestRestartDelay,
+                                                  GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                                  &delayed_restart_task,
+                                                  NULL);
+  }
 }
 
 
@@ -1564,7 +1633,7 @@ delayed_restart_task(void *cls)
  * @param cls closure, NULL
  */
 static void
-maint_child_death(void *cls)
+maint_child_death (void *cls)
 {
   struct ServiceList *pos;
   struct ServiceList *next;
@@ -1577,199 +1646,200 @@ maint_child_death(void *cls)
   unsigned long statusCode;
   const struct GNUNET_DISK_FileHandle *pr;
 
-  (void)cls;
-  pr = GNUNET_DISK_pipe_handle(sigpipe, GNUNET_DISK_PIPE_END_READ);
+  (void) cls;
+  pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ);
   child_death_task = NULL;
   /* consume the signal */
-  GNUNET_break(0 < GNUNET_DISK_file_read(pr, &c, sizeof(c)));
+  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;
+  {
+    next = pos->next;
 
-      if (NULL == pos->proc)
-        {
-          if (GNUNET_YES == in_shutdown)
-            free_service(pos);
-          continue;
-        }
+    if (NULL == pos->proc)
+    {
+      if (GNUNET_YES == in_shutdown)
+        free_service (pos);
+      continue;
+    }
 #if HAVE_WAIT4
-      if (NULL != wait_file)
-        {
-          /* need to use 'wait4()' to obtain and log performance data */
-          struct rusage ru;
-          int status;
-          pid_t pid;
-
-          pid = GNUNET_OS_process_get_pid(pos->proc);
-          ret = wait4(pid, &status, WNOHANG, &ru);
-          if (ret <= 0)
-            continue; /* no process done */
-          if (WIFEXITED(status))
-            {
-              statusType = GNUNET_OS_PROCESS_EXITED;
-              statusCode = WEXITSTATUS(status);
-            }
-          else if (WIFSIGNALED(status))
-            {
-              statusType = GNUNET_OS_PROCESS_SIGNALED;
-              statusCode = WTERMSIG(status);
-            }
-          else if (WIFSTOPPED(status))
-            {
-              statusType = GNUNET_OS_PROCESS_SIGNALED;
-              statusCode = WSTOPSIG(status);
-            }
+    if (NULL != wait_file)
+    {
+      /* need to use 'wait4()' to obtain and log performance data */
+      struct rusage ru;
+      int status;
+      pid_t pid;
+
+      pid = GNUNET_OS_process_get_pid (pos->proc);
+      ret = wait4 (pid, &status, WNOHANG, &ru);
+      if (ret <= 0)
+        continue;     /* no process done */
+      if (WIFEXITED (status))
+      {
+        statusType = GNUNET_OS_PROCESS_EXITED;
+        statusCode = WEXITSTATUS (status);
+      }
+      else if (WIFSIGNALED (status))
+      {
+        statusType = GNUNET_OS_PROCESS_SIGNALED;
+        statusCode = WTERMSIG (status);
+      }
+      else if (WIFSTOPPED (status))
+      {
+        statusType = GNUNET_OS_PROCESS_SIGNALED;
+        statusCode = WSTOPSIG (status);
+      }
 #ifdef WIFCONTINUED
-          else if (WIFCONTINUED(status))
-            {
-              statusType = GNUNET_OS_PROCESS_RUNNING;
-              statusCode = 0;
-            }
-#endif
-          else
-            {
-              statusType = GNUNET_OS_PROCESS_UNKNOWN;
-              statusCode = 0;
-            }
-          if ((GNUNET_OS_PROCESS_EXITED == statusType) ||
-              (GNUNET_OS_PROCESS_SIGNALED == statusType))
-            {
-              double utime = ru.ru_utime.tv_sec + (ru.ru_utime.tv_usec / 10e6);
-              double stime = ru.ru_stime.tv_sec + (ru.ru_stime.tv_usec / 10e6);
-              fprintf(wait_file,
-                      "%s(%u) %.3f %.3f %llu %llu %llu %llu %llu\n",
-                      pos->binary,
-                      (unsigned int)pid,
-                      utime,
-                      stime,
-                      (unsigned long long)ru.ru_maxrss,
-                      (unsigned long long)ru.ru_inblock,
-                      (unsigned long long)ru.ru_oublock,
-                      (unsigned long long)ru.ru_nvcsw,
-                      (unsigned long long)ru.ru_nivcsw);
-            }
-        }
-      else /* continue with JUST this "if" as "else" (intentionally no brackets!) */
+      else if (WIFCONTINUED (status))
+      {
+        statusType = GNUNET_OS_PROCESS_RUNNING;
+        statusCode = 0;
+      }
 #endif
-      if ((GNUNET_SYSERR == (ret = GNUNET_OS_process_status(pos->proc,
-                                                            &statusType,
-                                                            &statusCode))) ||
-          (ret == GNUNET_NO) || (statusType == GNUNET_OS_PROCESS_STOPPED) ||
-          (statusType == GNUNET_OS_PROCESS_UNKNOWN) ||
-          (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;
-        }
-      if (0 != pos->killed_at.abs_value_us)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                     _("Service `%s' took %s to terminate\n"),
+      {
+        statusType = GNUNET_OS_PROCESS_UNKNOWN;
+        statusCode = 0;
+      }
+      if ((GNUNET_OS_PROCESS_EXITED == statusType) ||
+          (GNUNET_OS_PROCESS_SIGNALED == statusType))
+      {
+        double utime = ru.ru_utime.tv_sec + (ru.ru_utime.tv_usec / 10e6);
+        double stime = ru.ru_stime.tv_sec + (ru.ru_stime.tv_usec / 10e6);
+        fprintf (wait_file,
+                 "%s(%u) %.3f %.3f %llu %llu %llu %llu %llu\n",
+                 pos->binary,
+                 (unsigned int) pid,
+                 utime,
+                 stime,
+                 (unsigned long long) ru.ru_maxrss,
+                 (unsigned long long) ru.ru_inblock,
+                 (unsigned long long) ru.ru_oublock,
+                 (unsigned long long) ru.ru_nvcsw,
+                 (unsigned long long) ru.ru_nivcsw);
+      }
+    }
+    else   /* continue with JUST this "if" as "else" (intentionally no brackets!) */
+#endif
+    if ((GNUNET_SYSERR == (ret = GNUNET_OS_process_status (pos->proc,
+                                                           &statusType,
+                                                           &statusCode))) ||
+        (ret == GNUNET_NO) || (statusType == GNUNET_OS_PROCESS_STOPPED) ||
+        (statusType == GNUNET_OS_PROCESS_UNKNOWN) ||
+        (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;
+    }
+    if (0 != pos->killed_at.abs_value_us)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _ ("Service `%s' took %s to terminate\n"),
+                  pos->name,
+                  GNUNET_STRINGS_relative_time_to_string (
+                    GNUNET_TIME_absolute_get_duration (pos->killed_at),
+                    GNUNET_YES));
+    }
+    GNUNET_OS_process_destroy (pos->proc);
+    pos->proc = NULL;
+    broadcast_status (pos->name, GNUNET_ARM_SERVICE_STOPPED, NULL);
+    if (NULL != pos->killing_client)
+    {
+      signal_result (pos->killing_client,
                      pos->name,
-                     GNUNET_STRINGS_relative_time_to_string(
-                       GNUNET_TIME_absolute_get_duration(pos->killed_at),
-                       GNUNET_YES));
-        }
-      GNUNET_OS_process_destroy(pos->proc);
-      pos->proc = NULL;
-      broadcast_status(pos->name, GNUNET_ARM_SERVICE_STOPPED, NULL);
-      if (NULL != pos->killing_client)
-        {
-          signal_result(pos->killing_client,
-                        pos->name,
-                        pos->killing_client_request_id,
-                        GNUNET_ARM_RESULT_STOPPED);
-          pos->killing_client = NULL;
-          pos->killing_client_request_id = 0;
-        }
-      if (GNUNET_YES != in_shutdown)
+                     pos->killing_client_request_id,
+                     GNUNET_ARM_RESULT_STOPPED);
+      pos->killing_client = NULL;
+      pos->killing_client_request_id = 0;
+    }
+    if (GNUNET_YES != in_shutdown)
+    {
+      pos->last_exit_status = statcode;
+      if ((statusType == GNUNET_OS_PROCESS_EXITED) && (statcode == 0))
+      {
+        /* process terminated normally, allow restart at any time */
+        pos->restart_at.abs_value_us = 0;
+        GNUNET_log (
+          GNUNET_ERROR_TYPE_INFO,
+          _ ("Service `%s' terminated normally, will restart at any time\n"),
+          pos->name);
+        /* process can still be re-started on-demand, ensure it is re-started if there is demand */
+        for (sli = pos->listen_head; NULL != sli; sli = sli->next)
         {
-          if ((statusType == GNUNET_OS_PROCESS_EXITED) && (statcode == 0))
-            {
-              /* process terminated normally, allow restart at any time */
-              pos->restart_at.abs_value_us = 0;
-              GNUNET_log(
-                GNUNET_ERROR_TYPE_INFO,
-                _("Service `%s' terminated normally, will restart at any time\n"),
-                pos->name);
-              /* process can still be re-started on-demand, ensure it is re-started if there is demand */
-              for (sli = pos->listen_head; NULL != sli; sli = sli->next)
-                {
-                  GNUNET_break(NULL == sli->accept_task);
-                  sli->accept_task =
-                    GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
-                                                  sli->listen_socket,
-                                                  &accept_connection,
-                                                  sli);
-                }
-            }
-          else
-            {
-              GNUNET_log(
-                GNUNET_ERROR_TYPE_INFO,
-                _("Service `%s' terminated with status %s/%d, will restart in %s\n"),
-                pos->name,
-                statstr,
-                statcode,
-                GNUNET_STRINGS_relative_time_to_string(pos->backoff, GNUNET_YES));
-              {
-                /* Reduce backoff based on runtime of the process,
-                   so that there is a cool-down if a process actually
-                   runs for a while. */
-                struct GNUNET_TIME_Relative runtime;
-                unsigned int minutes;
-
-                runtime = GNUNET_TIME_absolute_get_duration(pos->restart_at);
-                minutes =
-                  runtime.rel_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us;
-                if (minutes > 31)
-                  pos->backoff = GNUNET_TIME_UNIT_ZERO;
-                else
-                  pos->backoff.rel_value_us <<= minutes;
-              }
-              /* schedule restart */
-              pos->restart_at = GNUNET_TIME_relative_to_absolute(pos->backoff);
-              pos->backoff = GNUNET_TIME_STD_BACKOFF(pos->backoff);
-              if (NULL != 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);
-            }
+          GNUNET_break (NULL == sli->accept_task);
+          sli->accept_task =
+            GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                           sli->listen_socket,
+                                           &accept_connection,
+                                           sli);
         }
+      }
       else
+      {
+        GNUNET_log (
+          GNUNET_ERROR_TYPE_WARNING,
+          _ ("Service `%s' terminated with status %s/%d, will restart in %s\n"),
+          pos->name,
+          statstr,
+          statcode,
+          GNUNET_STRINGS_relative_time_to_string (pos->backoff, GNUNET_YES));
         {
-          free_service(pos);
+          /* Reduce backoff based on runtime of the process,
+             so that there is a cool-down if a process actually
+             runs for a while. */
+          struct GNUNET_TIME_Relative runtime;
+          unsigned int minutes;
+
+          runtime = GNUNET_TIME_absolute_get_duration (pos->restart_at);
+          minutes =
+            runtime.rel_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us;
+          if (minutes > 31)
+            pos->backoff = GNUNET_TIME_UNIT_ZERO;
+          else
+            pos->backoff.rel_value_us <<= minutes;
         }
+        /* schedule restart */
+        pos->restart_at = GNUNET_TIME_relative_to_absolute (pos->backoff);
+        pos->backoff = GNUNET_TIME_STD_BACKOFF (pos->backoff);
+        if (NULL != 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);
+      }
     }
+    else
+    {
+      free_service (pos);
+    }
+  }
   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 ((NULL == running_head) && (GNUNET_YES == in_shutdown))
-    do_shutdown();
+    do_shutdown ();
   else if (GNUNET_YES == in_shutdown)
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-               "Delaying shutdown after child's death, still have %u children\n",
-               list_count(running_head));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Delaying shutdown after child's death, still have %u children\n",
+                list_count (running_head));
 }
 
 
@@ -1778,17 +1848,17 @@ maint_child_death(void *cls)
  * respective handler by writing to the trigger pipe.
  */
 static void
-sighandler_child_death()
+sighandler_child_death ()
 {
   static char c;
   int old_errno = errno; /* back-up errno */
 
-  GNUNET_break(
+  GNUNET_break (
     1 ==
-    GNUNET_DISK_file_write(GNUNET_DISK_pipe_handle(sigpipe,
-                                                   GNUNET_DISK_PIPE_END_WRITE),
-                           &c,
-                           sizeof(c)));
+    GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle (sigpipe,
+                                                     GNUNET_DISK_PIPE_END_WRITE),
+                            &c,
+                            sizeof(c)));
   errno = old_errno; /* restore errno */
 }
 
@@ -1802,7 +1872,7 @@ sighandler_child_death()
  * @return #GNUNET_OK (continue)
  */
 static void
-setup_service(void *cls, const char *section)
+setup_service (void *cls, const char *section)
 {
   struct ServiceList *sl;
   char *binary;
@@ -1812,94 +1882,94 @@ setup_service(void *cls, const char *section)
   socklen_t *addr_lens;
   int ret;
 
-  (void)cls;
-  if (0 == strcasecmp(section, "arm"))
+  (void) cls;
+  if (0 == strcasecmp (section, "arm"))
     return;
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string(cfg, section, "BINARY", &binary))
-    {
-      /* not a service section */
-      return;
-    }
+      GNUNET_CONFIGURATION_get_value_string (cfg, section, "BINARY", &binary))
+  {
+    /* not a service section */
+    return;
+  }
   if ((GNUNET_YES ==
-       GNUNET_CONFIGURATION_have_value(cfg, section, "RUN_PER_USER")) &&
+       GNUNET_CONFIGURATION_have_value (cfg, section, "RUN_PER_USER")) &&
       (GNUNET_YES ==
-       GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "RUN_PER_USER")))
+       GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "RUN_PER_USER")))
+  {
+    if (GNUNET_NO == start_user)
     {
-      if (GNUNET_NO == start_user)
-        {
-          GNUNET_free(binary);
-          return; /* user service, and we don't deal with those */
-        }
+      GNUNET_free (binary);
+      return;     /* user service, and we don't deal with those */
     }
+  }
   else
+  {
+    if (GNUNET_NO == start_system)
     {
-      if (GNUNET_NO == start_system)
-        {
-          GNUNET_free(binary);
-          return; /* system service, and we don't deal with those */
-        }
+      GNUNET_free (binary);
+      return;     /* system service, and we don't deal with those */
     }
-  sl = find_service(section);
+  }
+  sl = find_service (section);
   if (NULL != sl)
-    {
-      /* got the same section twice!? */
-      GNUNET_break(0);
-      GNUNET_free(binary);
-      return;
-    }
+  {
+    /* got the same section twice!? */
+    GNUNET_break (0);
+    GNUNET_free (binary);
+    return;
+  }
   config = NULL;
-  if (((GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg,
-                                                             section,
-                                                             "CONFIG",
-                                                             &config)) &&
-       (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg,
-                                                             "PATHS",
-                                                             "DEFAULTCONFIG",
-                                                             &config))) ||
-      (0 != stat(config, &sbuf)))
+  if (((GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                                              section,
+                                                              "CONFIG",
+                                                              &config)) &&
+       (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                                              "PATHS",
+                                                              "DEFAULTCONFIG",
+                                                              &config))) ||
+      (0 != stat (config, &sbuf)))
+  {
+    if (NULL != config)
     {
-      if (NULL != config)
-        {
-          GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_WARNING,
-                                    section,
-                                    "CONFIG",
-                                    strerror(errno));
-          GNUNET_free(config);
-          config = NULL;
-        }
+      GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
+                                 section,
+                                 "CONFIG",
+                                 strerror (errno));
+      GNUNET_free (config);
+      config = NULL;
     }
-  sl = GNUNET_new(struct ServiceList);
-  sl->name = GNUNET_strdup(section);
+  }
+  sl = GNUNET_new (struct ServiceList);
+  sl->name = GNUNET_strdup (section);
   sl->binary = binary;
   sl->config = config;
   sl->backoff = GNUNET_TIME_UNIT_MILLISECONDS;
   sl->restart_at = GNUNET_TIME_UNIT_FOREVER_ABS;
-  if (GNUNET_CONFIGURATION_have_value(cfg, section, "PIPECONTROL"))
+  if (GNUNET_CONFIGURATION_have_value (cfg, section, "PIPECONTROL"))
     sl->pipe_control =
-      GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "PIPECONTROL");
-  GNUNET_CONTAINER_DLL_insert(running_head, running_tail, sl);
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "PIPECONTROL");
+  GNUNET_CONTAINER_DLL_insert (running_head, running_tail, sl);
   if (GNUNET_YES ==
-      GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "IMMEDIATE_START"))
-    {
-      sl->force_start = GNUNET_YES;
-      if (GNUNET_YES ==
-          GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "NOARMBIND"))
-        return;
-    }
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "IMMEDIATE_START"))
+  {
+    sl->force_start = GNUNET_YES;
+    if (GNUNET_YES ==
+        GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "NOARMBIND"))
+      return;
+  }
   else
-    {
-      if (GNUNET_YES !=
-          GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "START_ON_DEMAND"))
-        return;
-    }
-  if (0 >= (ret = get_server_addresses(section, cfg, &addrs, &addr_lens)))
+  {
+    if (GNUNET_YES !=
+        GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "START_ON_DEMAND"))
+      return;
+  }
+  if (0 >= (ret = get_server_addresses (section, cfg, &addrs, &addr_lens)))
     return;
   /* this will free (or capture) addrs[i] */
-  for (unsigned int i = 0; i < (unsigned int)ret; i++)
-    create_listen_socket(addrs[i], addr_lens[i], sl);
-  GNUNET_free(addrs);
-  GNUNET_free(addr_lens);
+  for (unsigned int i = 0; i < (unsigned int) ret; i++)
+    create_listen_socket (addrs[i], addr_lens[i], sl);
+  GNUNET_free (addrs);
+  GNUNET_free (addr_lens);
 }
 
 
@@ -1912,16 +1982,16 @@ setup_service(void *cls, const char *section)
  * @return @a client
  */
 static void *
-client_connect_cb(void *cls,
-                  struct GNUNET_SERVICE_Client *client,
-                  struct GNUNET_MQ_Handle *mq)
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *client,
+                   struct GNUNET_MQ_Handle *mq)
 {
   /* All clients are considered to be of the "monitor" kind
    * (that is, they don't affect ARM shutdown).
    */
-  (void)cls;
-  (void)mq;
-  GNUNET_SERVICE_client_mark_monitor(client);
+  (void) cls;
+  (void) mq;
+  GNUNET_SERVICE_client_mark_monitor (client);
   return client;
 }
 
@@ -1934,12 +2004,12 @@ client_connect_cb(void *cls,
  * @param app_ctx must match @a client
  */
 static void
-client_disconnect_cb(void *cls,
-                     struct GNUNET_SERVICE_Client *client,
-                     void *app_ctx)
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *app_ctx)
 {
-  (void)cls;
-  GNUNET_assert(client == app_ctx);
+  (void) cls;
+  GNUNET_assert (client == app_ctx);
   for (struct ServiceList *sl = running_head; NULL != sl; sl = sl->next)
     if (sl->killing_client == client)
       sl->killing_client = NULL;
@@ -1955,18 +2025,18 @@ client_disconnect_cb(void *cls,
  *         #GNUNET_SYSERR to close it (signal serious error)
  */
 static void
-handle_monitor(void *cls, const struct GNUNET_MessageHeader *message)
+handle_monitor (void *cls, const struct GNUNET_MessageHeader *message)
 {
   struct GNUNET_SERVICE_Client *client = cls;
 
-  (void)message;
+  (void) message;
   /* FIXME: might want to start by letting monitor know about
      services that are already running */
   /* Removal is handled by the server implementation, internally. */
-  GNUNET_notification_context_add(notifier,
-                                  GNUNET_SERVICE_client_get_mq(client));
-  broadcast_status("arm", GNUNET_ARM_SERVICE_MONITORING_STARTED, client);
-  GNUNET_SERVICE_client_continue(client);
+  GNUNET_notification_context_add (notifier,
+                                   GNUNET_SERVICE_client_get_mq (client));
+  broadcast_status ("arm", GNUNET_ARM_SERVICE_MONITORING_STARTED, client);
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -1978,71 +2048,71 @@ handle_monitor(void *cls, const struct GNUNET_MessageHeader *message)
  * @param c configuration to use
  */
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *c,
-    struct GNUNET_SERVICE_Handle *serv)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_SERVICE_Handle *serv)
 {
   struct ServiceList *sl;
 
-  (void)cls;
+  (void) cls;
   cfg = c;
   service = serv;
-  GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL);
-  child_death_task = GNUNET_SCHEDULER_add_read_file(
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
+  child_death_task = GNUNET_SCHEDULER_add_read_file (
     GNUNET_TIME_UNIT_FOREVER_REL,
-    GNUNET_DISK_pipe_handle(sigpipe, GNUNET_DISK_PIPE_END_READ),
+    GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ),
     &maint_child_death,
     NULL);
 #if HAVE_WAIT4
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_get_value_filename(cfg,
-                                              "ARM",
-                                              "RESOURCE_DIAGNOSTICS",
-                                              &wait_filename))
+      GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                               "ARM",
+                                               "RESOURCE_DIAGNOSTICS",
+                                               &wait_filename))
+  {
+    wait_file = fopen (wait_filename, "w");
+    if (NULL == wait_file)
     {
-      wait_file = fopen(wait_filename, "w");
-      if (NULL == wait_file)
-        {
-          GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR,
-                                   "fopen",
-                                   wait_filename);
-        }
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
+                                "fopen",
+                                wait_filename);
     }
+  }
 #endif
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                         "ARM",
-                                                         "GLOBAL_PREFIX",
-                                                         &prefix_command))
-    prefix_command = GNUNET_strdup("");
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                          "ARM",
+                                                          "GLOBAL_PREFIX",
+                                                          &prefix_command))
+    prefix_command = GNUNET_strdup ("");
   else
-    prefix_command = GNUNET_CONFIGURATION_expand_dollar(cfg, prefix_command);
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg,
-                                                         "ARM",
-                                                         "GLOBAL_POSTFIX",
-                                                         &final_option))
-    final_option = GNUNET_strdup("");
+    prefix_command = GNUNET_CONFIGURATION_expand_dollar (cfg, prefix_command);
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                          "ARM",
+                                                          "GLOBAL_POSTFIX",
+                                                          &final_option))
+    final_option = GNUNET_strdup ("");
   else
-    final_option = GNUNET_CONFIGURATION_expand_dollar(cfg, final_option);
+    final_option = GNUNET_CONFIGURATION_expand_dollar (cfg, final_option);
   start_user =
-    GNUNET_CONFIGURATION_get_value_yesno(cfg, "ARM", "START_USER_SERVICES");
+    GNUNET_CONFIGURATION_get_value_yesno (cfg, "ARM", "START_USER_SERVICES");
   start_system =
-    GNUNET_CONFIGURATION_get_value_yesno(cfg, "ARM", "START_SYSTEM_SERVICES");
+    GNUNET_CONFIGURATION_get_value_yesno (cfg, "ARM", "START_SYSTEM_SERVICES");
   if ((GNUNET_NO == start_user) && (GNUNET_NO == start_system))
-    {
-      GNUNET_log(
-        GNUNET_ERROR_TYPE_ERROR,
-        "Please configure either START_USER_SERVICES or START_SYSTEM_SERVICES or both.\n");
-      GNUNET_SCHEDULER_shutdown();
-      global_ret = 1;
-      return;
-    }
-  GNUNET_CONFIGURATION_iterate_sections(cfg, &setup_service, NULL);
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_ERROR,
+      "Please configure either START_USER_SERVICES or START_SYSTEM_SERVICES or both.\n");
+    GNUNET_SCHEDULER_shutdown ();
+    global_ret = 1;
+    return;
+  }
+  GNUNET_CONFIGURATION_iterate_sections (cfg, &setup_service, NULL);
 
   /* start default services... */
   for (sl = running_head; NULL != sl; sl = sl->next)
     if (GNUNET_YES == sl->force_start)
-      start_process(sl, NULL, 0);
-  notifier = GNUNET_notification_context_create(MAX_NOTIFY_QUEUE);
+      start_process (sl, NULL, 0);
+  notifier = GNUNET_notification_context_create (MAX_NOTIFY_QUEUE);
 }
 
 
@@ -2054,61 +2124,64 @@ run(void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main(int argc, char *const *argv)
+main (int argc, char *const *argv)
 {
   struct GNUNET_SIGNAL_Context *shc_chld;
-  struct GNUNET_MQ_MessageHandler handlers[] =
-  { GNUNET_MQ_hd_var_size(start,
-                          GNUNET_MESSAGE_TYPE_ARM_START,
-                          struct GNUNET_ARM_Message,
-                          NULL),
-    GNUNET_MQ_hd_var_size(stop,
-                          GNUNET_MESSAGE_TYPE_ARM_STOP,
-                          struct GNUNET_ARM_Message,
-                          NULL),
-    GNUNET_MQ_hd_fixed_size(monitor,
-                            GNUNET_MESSAGE_TYPE_ARM_MONITOR,
-                            struct GNUNET_MessageHeader,
-                            NULL),
-    GNUNET_MQ_hd_fixed_size(list,
-                            GNUNET_MESSAGE_TYPE_ARM_LIST,
-                            struct GNUNET_ARM_Message,
-                            NULL),
-    GNUNET_MQ_hd_fixed_size(test,
-                            GNUNET_MESSAGE_TYPE_ARM_TEST,
-                            struct GNUNET_MessageHeader,
-                            NULL),
-    GNUNET_MQ_handler_end() };
-
-  sigpipe = GNUNET_DISK_pipe(GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO);
-  GNUNET_assert(NULL != sigpipe);
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_var_size (start,
+                           GNUNET_MESSAGE_TYPE_ARM_START,
+                           struct GNUNET_ARM_Message,
+                           NULL),
+    GNUNET_MQ_hd_var_size (stop,
+                           GNUNET_MESSAGE_TYPE_ARM_STOP,
+                           struct GNUNET_ARM_Message,
+                           NULL),
+    GNUNET_MQ_hd_fixed_size (monitor,
+                             GNUNET_MESSAGE_TYPE_ARM_MONITOR,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (list,
+                             GNUNET_MESSAGE_TYPE_ARM_LIST,
+                             struct GNUNET_ARM_Message,
+                             NULL),
+    GNUNET_MQ_hd_fixed_size (test,
+                             GNUNET_MESSAGE_TYPE_ARM_TEST,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_handler_end ()
+  };
+
+  sigpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO);
+  GNUNET_assert (NULL != sigpipe);
   shc_chld =
-    GNUNET_SIGNAL_handler_install(GNUNET_SIGCHLD, &sighandler_child_death);
-  if (0 != GNUNET_SERVICE_run_(argc,
-                               argv,
-                               "arm",
-                               GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN,
-                               &run,
-                               &client_connect_cb,
-                               &client_disconnect_cb,
-                               NULL,
-                               handlers))
+    GNUNET_SIGNAL_handler_install (GNUNET_SIGCHLD,
+                                   &sighandler_child_death);
+  if (0 != GNUNET_SERVICE_run_ (argc,
+                                argv,
+                                "arm",
+                                GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN
+                                | GNUNET_SERVICE_OPTION_CLOSE_LSOCKS,
+                                &run,
+                                &client_connect_cb,
+                                &client_disconnect_cb,
+                                NULL,
+                                handlers))
     global_ret = 2;
 #if HAVE_WAIT4
   if (NULL != wait_file)
-    {
-      fclose(wait_file);
-      wait_file = NULL;
-    }
+  {
+    fclose (wait_file);
+    wait_file = NULL;
+  }
   if (NULL != wait_filename)
-    {
-      GNUNET_free(wait_filename);
-      wait_filename = NULL;
-    }
+  {
+    GNUNET_free (wait_filename);
+    wait_filename = NULL;
+  }
 #endif
-  GNUNET_SIGNAL_handler_uninstall(shc_chld);
+  GNUNET_SIGNAL_handler_uninstall (shc_chld);
   shc_chld = NULL;
-  GNUNET_DISK_pipe_close(sigpipe);
+  GNUNET_DISK_pipe_close (sigpipe);
   sigpipe = NULL;
   return global_ret;
 }
@@ -2120,11 +2193,11 @@ main(int argc, char *const *argv)
 /**
  * MINIMIZE heap size (way below 128k) since this process doesn't need much.
  */
-void __attribute__ ((constructor)) GNUNET_ARM_memory_init()
+void __attribute__ ((constructor)) GNUNET_ARM_memory_init ()
 {
-  mallopt(M_TRIM_THRESHOLD, 4 * 1024);
-  mallopt(M_TOP_PAD, 1 * 1024);
-  malloc_trim(0);
+  mallopt (M_TRIM_THRESHOLD, 4 * 1024);
+  mallopt (M_TOP_PAD, 1 * 1024);
+  malloc_trim (0);
 }
 #endif