indent

1 files changed, 438 insertions, 382 deletions

diff --git a/src/arm/arm_api.c b/src/arm/arm_api.c
index 4c3bb0488..dc5c9c25b 100644
--- a/src/arm/arm_api.c
+++ b/src/arm/arm_api.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     Copyright (C) 2009, 2010, 2012, 2013, 2016 GNUnet e.V.
+     Copyright (C) 2009, 2010, 2012, 2013, 2016, 2019 GNUnet e.V.
 
      GNUnet is free software: you can redistribute it and/or modify it
      under the terms of the GNU Affero General Public License as published
@@ -30,14 +30,15 @@
 #include "gnunet_protocols.h"
 #include "arm.h"
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "arm-api", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "arm-api", __VA_ARGS__)
 
 
 /**
  * Entry in a doubly-linked list of operations awaiting for replies
  * (in-order) from the ARM service.
  */
-struct GNUNET_ARM_Operation {
+struct GNUNET_ARM_Operation
+{
   /**
    * This is a doubly-linked list.
    */
@@ -93,7 +94,8 @@ struct GNUNET_ARM_Operation {
 /**
  * Handle for interacting with ARM.
  */
-struct GNUNET_ARM_Handle {
+struct GNUNET_ARM_Handle
+{
   /**
    * Our connection to the ARM service.
    */
@@ -164,7 +166,7 @@ struct GNUNET_ARM_Handle {
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 static int
-reconnect_arm(struct GNUNET_ARM_Handle *h);
+reconnect_arm (struct GNUNET_ARM_Handle *h);
 
 
 /**
@@ -173,12 +175,12 @@ reconnect_arm(struct GNUNET_ARM_Handle *h);
  * @param cls the `struct GNUNET_ARM_Handle`
  */
 static void
-reconnect_arm_task(void *cls)
+reconnect_arm_task (void *cls)
 {
   struct GNUNET_ARM_Handle *h = cls;
 
   h->reconnect_task = NULL;
-  reconnect_arm(h);
+  reconnect_arm (h);
 }
 
 
@@ -189,31 +191,31 @@ reconnect_arm_task(void *cls)
  * @param h our handle
  */
 static void
-reconnect_arm_later(struct GNUNET_ARM_Handle *h)
+reconnect_arm_later (struct GNUNET_ARM_Handle *h)
 {
   struct GNUNET_ARM_Operation *op;
 
   if (NULL != h->mq)
-    {
-      GNUNET_MQ_destroy(h->mq);
-      h->mq = NULL;
-    }
+  {
+    GNUNET_MQ_destroy (h->mq);
+    h->mq = NULL;
+  }
   h->currently_up = GNUNET_NO;
-  GNUNET_assert(NULL == h->reconnect_task);
+  GNUNET_assert (NULL == h->reconnect_task);
   h->reconnect_task =
-    GNUNET_SCHEDULER_add_delayed(h->retry_backoff, &reconnect_arm_task, h);
+    GNUNET_SCHEDULER_add_delayed (h->retry_backoff, &reconnect_arm_task, h);
   while (NULL != (op = h->operation_pending_head))
-    {
-      if (NULL != op->result_cont)
-        op->result_cont(op->cont_cls, GNUNET_ARM_REQUEST_DISCONNECTED, 0);
-      if (NULL != op->list_cont)
-        op->list_cont(op->cont_cls, GNUNET_ARM_REQUEST_DISCONNECTED, 0, NULL);
-      GNUNET_ARM_operation_cancel(op);
-    }
-  GNUNET_assert(NULL == h->operation_pending_head);
-  h->retry_backoff = GNUNET_TIME_STD_BACKOFF(h->retry_backoff);
+  {
+    if (NULL != op->result_cont)
+      op->result_cont (op->cont_cls, GNUNET_ARM_REQUEST_DISCONNECTED, 0);
+    if (NULL != op->list_cont)
+      op->list_cont (op->cont_cls, GNUNET_ARM_REQUEST_DISCONNECTED, 0, NULL);
+    GNUNET_ARM_operation_cancel (op);
+  }
+  GNUNET_assert (NULL == h->operation_pending_head);
+  h->retry_backoff = GNUNET_TIME_STD_BACKOFF (h->retry_backoff);
   if (NULL != h->conn_status)
-    h->conn_status(h->conn_status_cls, GNUNET_NO);
+    h->conn_status (h->conn_status_cls, GNUNET_NO);
 }
 
 
@@ -225,11 +227,11 @@ reconnect_arm_later(struct GNUNET_ARM_Handle *h)
  * @return NULL if not found
  */
 static struct GNUNET_ARM_Operation *
-find_op_by_id(struct GNUNET_ARM_Handle *h, uint64_t id)
+find_op_by_id (struct GNUNET_ARM_Handle *h,
+               uint64_t id)
 {
-  struct GNUNET_ARM_Operation *result;
-
-  for (result = h->operation_pending_head; NULL != result;
+  for (struct GNUNET_ARM_Operation *result = h->operation_pending_head;
+       NULL != result;
        result = result->next)
     if (id == result->id)
       return result;
@@ -244,7 +246,8 @@ find_op_by_id(struct GNUNET_ARM_Handle *h, uint64_t id)
  * @param res the message received from the arm service
  */
 static void
-handle_arm_result(void *cls, const struct GNUNET_ARM_ResultMessage *res)
+handle_arm_result (void *cls,
+                   const struct GNUNET_ARM_ResultMessage *res)
 {
   struct GNUNET_ARM_Handle *h = cls;
   struct GNUNET_ARM_Operation *op;
@@ -253,43 +256,46 @@ handle_arm_result(void *cls, const struct GNUNET_ARM_ResultMessage *res)
   GNUNET_ARM_ResultCallback result_cont;
   void *result_cont_cls;
 
-  id = GNUNET_ntohll(res->arm_msg.request_id);
-  op = find_op_by_id(h, id);
+  id = GNUNET_ntohll (res->arm_msg.request_id);
+  op = find_op_by_id (h, id);
   if (NULL == op)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Message with unknown id %llu\n",
-          (unsigned long long)id);
-      return;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Message with unknown id %llu\n",
+         (unsigned long long) id);
+    return;
+  }
 
-  result = (enum GNUNET_ARM_Result)ntohl(res->result);
-  if ((GNUNET_YES == op->is_arm_stop) && (GNUNET_ARM_RESULT_STOPPING == result))
+  result = (enum GNUNET_ARM_Result) ntohl (res->result);
+  if ( (GNUNET_YES == op->is_arm_stop) &&
+       (GNUNET_ARM_RESULT_STOPPING == result) )
+  {
+    /* special case: if we are stopping 'gnunet-service-arm', we do not just
+       wait for the result message, but also wait for the service to close
+       the connection (and then we have to close our client handle as well);
+       this is done by installing a different receive handler, waiting for
+       the connection to go down */
+    if (NULL != h->thm)
     {
-      /* special case: if we are stopping 'gnunet-service-arm', we do not just
-         wait for the result message, but also wait for the service to close
-         the connection (and then we have to close our client handle as well);
-         this is done by installing a different receive handler, waiting for
-         the connection to go down */
-      if (NULL != h->thm)
-        {
-          GNUNET_break(0);
-          op->result_cont(h->thm->cont_cls,
-                          GNUNET_ARM_REQUEST_SENT_OK,
-                          GNUNET_ARM_RESULT_IS_NOT_KNOWN);
-          GNUNET_free(h->thm);
-        }
-      GNUNET_CONTAINER_DLL_remove(h->operation_pending_head,
-                                  h->operation_pending_tail,
-                                  op);
-      h->thm = op;
-      return;
+      GNUNET_break (0);
+      op->result_cont (h->thm->cont_cls,
+                       GNUNET_ARM_REQUEST_SENT_OK,
+                       GNUNET_ARM_RESULT_IS_NOT_KNOWN);
+      GNUNET_free (h->thm);
     }
+    GNUNET_CONTAINER_DLL_remove (h->operation_pending_head,
+                                 h->operation_pending_tail,
+                                 op);
+    h->thm = op;
+    return;
+  }
   result_cont = op->result_cont;
   result_cont_cls = op->cont_cls;
-  GNUNET_ARM_operation_cancel(op);
+  GNUNET_ARM_operation_cancel (op);
   if (NULL != result_cont)
-    result_cont(result_cont_cls, GNUNET_ARM_REQUEST_SENT_OK, result);
+    result_cont (result_cont_cls,
+                 GNUNET_ARM_REQUEST_SENT_OK,
+                 result);
 }
 
 
@@ -303,7 +309,9 @@ handle_arm_result(void *cls, const struct GNUNET_ARM_ResultMessage *res)
  *          NULL if the index is out of bounds
  */
 static const char *
-pool_get (const char *pool_start, size_t pool_size, size_t str_index)
+pool_get (const char *pool_start,
+          size_t pool_size,
+          size_t str_index)
 {
   const char *str_start;
   const char *end;
@@ -311,7 +319,7 @@ pool_get (const char *pool_start, size_t pool_size, size_t str_index)
   if (str_index >= pool_size)
     return NULL;
   str_start = pool_start + str_index;
-  end = memchr(str_start, 0, pool_size - str_index);
+  end = memchr (str_start, 0, pool_size - str_index);
   if (NULL == end)
     return NULL;
   return str_start;
@@ -326,42 +334,42 @@ pool_get (const char *pool_start, size_t pool_size, size_t str_index)
  * @return #GNUNET_OK if message is well-formed
  */
 static int
-check_arm_list_result(void *cls,
-                      const struct GNUNET_ARM_ListResultMessage *lres)
+check_arm_list_result (void *cls,
+                       const struct GNUNET_ARM_ListResultMessage *lres)
 {
-  uint16_t rcount = ntohs(lres->count);
-  uint16_t msize = ntohs(lres->arm_msg.header.size) - sizeof(*lres);
+  uint16_t rcount = ntohs (lres->count);
+  uint16_t msize = ntohs (lres->arm_msg.header.size) - sizeof(*lres);
   struct GNUNET_ARM_ServiceInfoMessage *ssm;
   size_t pool_size;
   char *pool_start;
 
+  (void) cls;
   if ((rcount * sizeof (struct GNUNET_ARM_ServiceInfoMessage) > msize))
   {
     GNUNET_break_op (0);
     return GNUNET_NO;
   }
-
   ssm = (struct GNUNET_ARM_ServiceInfoMessage *) &lres[1];
   pool_start = (char *) (ssm + rcount);
   pool_size = msize - (rcount * sizeof (struct GNUNET_ARM_ServiceInfoMessage));
-
-  (void)cls;
   for (unsigned int i = 0; i < rcount; i++)
+  {
+    uint16_t name_index = ntohs (ssm->name_index);
+    uint16_t binary_index = ntohs (ssm->binary_index);
+    if (NULL == pool_get (pool_start, pool_size, name_index))
     {
-      uint16_t name_index = ntohs (ssm->name_index);
-      uint16_t binary_index = ntohs (ssm->binary_index);
-      if (NULL == pool_get (pool_start, pool_size, name_index))
-      {
-        GNUNET_break_op (0);
-        return GNUNET_NO;
-      }
-      if (NULL == pool_get (pool_start, pool_size, binary_index))
-      {
-        GNUNET_break_op (0);
-        return GNUNET_NO;
-      }
-      ssm++;
+      GNUNET_break_op (0);
+      return GNUNET_NO;
     }
+    if (NULL == pool_get (pool_start,
+                          pool_size,
+                          binary_index))
+    {
+      GNUNET_break_op (0);
+      return GNUNET_NO;
+    }
+    ssm++;
+  }
   return GNUNET_OK;
 }
 
@@ -373,12 +381,12 @@ check_arm_list_result(void *cls,
  * @param lres the message received from the arm service
  */
 static void
-handle_arm_list_result(void *cls,
-                       const struct GNUNET_ARM_ListResultMessage *lres)
+handle_arm_list_result (void *cls,
+                        const struct GNUNET_ARM_ListResultMessage *lres)
 {
   struct GNUNET_ARM_Handle *h = cls;
-  uint16_t rcount = ntohs(lres->count);
-  uint16_t msize = ntohs(lres->arm_msg.header.size) - sizeof(*lres);
+  uint16_t rcount = ntohs (lres->count);
+  uint16_t msize = ntohs (lres->arm_msg.header.size) - sizeof(*lres);
   struct GNUNET_ARM_ServiceInfo list[rcount];
   struct GNUNET_ARM_ServiceInfoMessage *ssm;
   struct GNUNET_ARM_Operation *op;
@@ -386,44 +394,50 @@ handle_arm_list_result(void *cls,
   size_t pool_size;
   char *pool_start;
 
-  id = GNUNET_ntohll(lres->arm_msg.request_id);
-  op = find_op_by_id(h, id);
+  id = GNUNET_ntohll (lres->arm_msg.request_id);
+  op = find_op_by_id (h, id);
   if (NULL == op)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Message with unknown id %llu\n",
-          (unsigned long long)id);
-      return;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Message with unknown id %llu\n",
+         (unsigned long long) id);
+    return;
+  }
 
-  GNUNET_assert ((rcount * sizeof (struct GNUNET_ARM_ServiceInfoMessage) <= msize));
+  GNUNET_assert ((rcount * sizeof (struct GNUNET_ARM_ServiceInfoMessage) <=
+                  msize));
 
   ssm = (struct GNUNET_ARM_ServiceInfoMessage *) &lres[1];
   pool_start = (char *) (ssm + rcount);
   pool_size = msize - (rcount * sizeof (struct GNUNET_ARM_ServiceInfoMessage));
 
   for (unsigned int i = 0; i < rcount; i++)
-    {
-      uint16_t name_index = ntohs (ssm->name_index);
-      uint16_t binary_index = ntohs (ssm->binary_index);
-      const char *name;
-      const char *binary;
-
-      GNUNET_assert (NULL != (name = pool_get (pool_start, pool_size, name_index)));
-      GNUNET_assert (NULL != (binary = pool_get (pool_start, pool_size, binary_index)));
-      list[i] = (struct GNUNET_ARM_ServiceInfo) {
-        .name = name,
-        .binary = binary,
-        .status = ntohl (ssm->status),
-        .last_started_at = GNUNET_TIME_absolute_ntoh (ssm->last_started_at),
-        .restart_at = GNUNET_TIME_absolute_ntoh (ssm->restart_at),
-        .last_exit_status = ntohs (ssm->last_exit_status),
-      };
-      ssm++;
-    }
+  {
+    uint16_t name_index = ntohs (ssm->name_index);
+    uint16_t binary_index = ntohs (ssm->binary_index);
+    const char *name;
+    const char *binary;
+
+    GNUNET_assert (NULL != (name = pool_get (pool_start, pool_size,
+                                             name_index)));
+    GNUNET_assert (NULL != (binary = pool_get (pool_start, pool_size,
+                                               binary_index)));
+    list[i] = (struct GNUNET_ARM_ServiceInfo) {
+      .name = name,
+      .binary = binary,
+      .status = ntohl (ssm->status),
+      .last_started_at = GNUNET_TIME_absolute_ntoh (ssm->last_started_at),
+      .restart_at = GNUNET_TIME_absolute_ntoh (ssm->restart_at),
+      .last_exit_status = ntohs (ssm->last_exit_status),
+    };
+    ssm++;
+  }
   if (NULL != op->list_cont)
-    op->list_cont(op->cont_cls, GNUNET_ARM_REQUEST_SENT_OK, rcount, list);
-  GNUNET_ARM_operation_cancel(op);
+    op->list_cont (op->cont_cls,
+                   GNUNET_ARM_REQUEST_SENT_OK,
+                   rcount,
+                   list);
+  GNUNET_ARM_operation_cancel (op);
 }
 
 
@@ -434,18 +448,20 @@ handle_arm_list_result(void *cls,
  * @param msg message received
  */
 static void
-handle_confirm(void *cls, const struct GNUNET_MessageHeader *msg)
+handle_confirm (void *cls,
+                const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_ARM_Handle *h = cls;
 
-  (void)msg;
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "Got confirmation from ARM that we are up!\n");
+  (void) msg;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Got confirmation from ARM that we are up!\n");
   if (GNUNET_NO == h->currently_up)
-    {
-      h->currently_up = GNUNET_YES;
-      if (NULL != h->conn_status)
-        h->conn_status(h->conn_status_cls, GNUNET_YES);
-    }
+  {
+    h->currently_up = GNUNET_YES;
+    if (NULL != h->conn_status)
+      h->conn_status (h->conn_status_cls, GNUNET_YES);
+  }
 }
 
 
@@ -458,22 +474,23 @@ handle_confirm(void *cls, const struct GNUNET_MessageHeader *msg)
  * @param error error code
  */
 static void
-mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
+mq_error_handler (void *cls,
+                  enum GNUNET_MQ_Error error)
 {
   struct GNUNET_ARM_Handle *h = cls;
   struct GNUNET_ARM_Operation *op;
 
-  (void)error;
+  (void) error;
   h->currently_up = GNUNET_NO;
   if (NULL != (op = h->thm))
-    {
-      h->thm = NULL;
-      op->result_cont(op->cont_cls,
-                      GNUNET_ARM_REQUEST_SENT_OK,
-                      GNUNET_ARM_RESULT_STOPPED);
-      GNUNET_free(op);
-    }
-  reconnect_arm_later(h);
+  {
+    h->thm = NULL;
+    op->result_cont (op->cont_cls,
+                     GNUNET_ARM_REQUEST_SENT_OK,
+                     GNUNET_ARM_RESULT_STOPPED);
+    GNUNET_free (op);
+  }
+  reconnect_arm_later (h);
 }
 
 
@@ -484,39 +501,48 @@ mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 static int
-reconnect_arm(struct GNUNET_ARM_Handle *h)
+reconnect_arm (struct GNUNET_ARM_Handle *h)
 {
-  struct GNUNET_MQ_MessageHandler handlers[] =
-  { GNUNET_MQ_hd_fixed_size(arm_result,
-                            GNUNET_MESSAGE_TYPE_ARM_RESULT,
-                            struct GNUNET_ARM_ResultMessage,
-                            h),
-    GNUNET_MQ_hd_var_size(arm_list_result,
-                          GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT,
-                          struct GNUNET_ARM_ListResultMessage,
-                          h),
-    GNUNET_MQ_hd_fixed_size(confirm,
-                            GNUNET_MESSAGE_TYPE_ARM_TEST,
-                            struct GNUNET_MessageHeader,
-                            h),
-    GNUNET_MQ_handler_end() };
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_fixed_size (arm_result,
+                             GNUNET_MESSAGE_TYPE_ARM_RESULT,
+                             struct GNUNET_ARM_ResultMessage,
+                             h),
+    GNUNET_MQ_hd_var_size (arm_list_result,
+                           GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT,
+                           struct GNUNET_ARM_ListResultMessage,
+                           h),
+    GNUNET_MQ_hd_fixed_size (confirm,
+                             GNUNET_MESSAGE_TYPE_ARM_TEST,
+                             struct GNUNET_MessageHeader,
+                             h),
+    GNUNET_MQ_handler_end ()
+  };
   struct GNUNET_MessageHeader *test;
   struct GNUNET_MQ_Envelope *env;
 
   if (NULL != h->mq)
     return GNUNET_OK;
-  GNUNET_assert(GNUNET_NO == h->currently_up);
-  h->mq = GNUNET_CLIENT_connect(h->cfg, "arm", handlers, &mq_error_handler, h);
+  GNUNET_assert (GNUNET_NO == h->currently_up);
+  h->mq = GNUNET_CLIENT_connect (h->cfg,
+                                 "arm",
+                                 handlers,
+                                 &mq_error_handler,
+                                 h);
   if (NULL == h->mq)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG, "GNUNET_CLIENT_connect returned NULL\n");
-      if (NULL != h->conn_status)
-        h->conn_status(h->conn_status_cls, GNUNET_SYSERR);
-      return GNUNET_SYSERR;
-    }
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "Sending TEST message to ARM\n");
-  env = GNUNET_MQ_msg(test, GNUNET_MESSAGE_TYPE_ARM_TEST);
-  GNUNET_MQ_send(h->mq, env);
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "GNUNET_CLIENT_connect returned NULL\n");
+    if (NULL != h->conn_status)
+      h->conn_status (h->conn_status_cls,
+                      GNUNET_SYSERR);
+    return GNUNET_SYSERR;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Sending TEST message to ARM\n");
+  env = GNUNET_MQ_msg (test,
+                       GNUNET_MESSAGE_TYPE_ARM_TEST);
+  GNUNET_MQ_send (h->mq, env);
   return GNUNET_OK;
 }
 
@@ -533,21 +559,21 @@ reconnect_arm(struct GNUNET_ARM_Handle *h)
  * @return context to use for further ARM operations, NULL on error.
  */
 struct GNUNET_ARM_Handle *
-GNUNET_ARM_connect(const struct GNUNET_CONFIGURATION_Handle *cfg,
-                   GNUNET_ARM_ConnectionStatusCallback conn_status,
-                   void *conn_status_cls)
+GNUNET_ARM_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                    GNUNET_ARM_ConnectionStatusCallback conn_status,
+                    void *conn_status_cls)
 {
   struct GNUNET_ARM_Handle *h;
 
-  h = GNUNET_new(struct GNUNET_ARM_Handle);
+  h = GNUNET_new (struct GNUNET_ARM_Handle);
   h->cfg = cfg;
   h->conn_status = conn_status;
   h->conn_status_cls = conn_status_cls;
-  if (GNUNET_OK != reconnect_arm(h))
-    {
-      GNUNET_free(h);
-      return NULL;
-    }
+  if (GNUNET_OK != reconnect_arm (h))
+  {
+    GNUNET_free (h);
+    return NULL;
+  }
   return h;
 }
 
@@ -558,38 +584,43 @@ GNUNET_ARM_connect(const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param h the handle that was being used
  */
 void
-GNUNET_ARM_disconnect(struct GNUNET_ARM_Handle *h)
+GNUNET_ARM_disconnect (struct GNUNET_ARM_Handle *h)
 {
   struct GNUNET_ARM_Operation *op;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from ARM service\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from ARM service\n");
   while (NULL != (op = h->operation_pending_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (h->operation_pending_head,
+                                 h->operation_pending_tail,
+                                 op);
+    if (NULL != op->result_cont)
+      op->result_cont (op->cont_cls,
+                       GNUNET_ARM_REQUEST_DISCONNECTED,
+                       0);
+    if (NULL != op->list_cont)
+      op->list_cont (op->cont_cls,
+                     GNUNET_ARM_REQUEST_DISCONNECTED,
+                     0,
+                     NULL);
+    if (NULL != op->async)
     {
-      GNUNET_CONTAINER_DLL_remove(h->operation_pending_head,
-                                  h->operation_pending_tail,
-                                  op);
-      if (NULL != op->result_cont)
-        op->result_cont(op->cont_cls, GNUNET_ARM_REQUEST_DISCONNECTED, 0);
-      if (NULL != op->list_cont)
-        op->list_cont(op->cont_cls, GNUNET_ARM_REQUEST_DISCONNECTED, 0, NULL);
-      if (NULL != op->async)
-        {
-          GNUNET_SCHEDULER_cancel(op->async);
-          op->async = NULL;
-        }
-      GNUNET_free(op);
+      GNUNET_SCHEDULER_cancel (op->async);
+      op->async = NULL;
     }
+    GNUNET_free (op);
+  }
   if (NULL != h->mq)
-    {
-      GNUNET_MQ_destroy(h->mq);
-      h->mq = NULL;
-    }
+  {
+    GNUNET_MQ_destroy (h->mq);
+    h->mq = NULL;
+  }
   if (NULL != h->reconnect_task)
-    {
-      GNUNET_SCHEDULER_cancel(h->reconnect_task);
-      h->reconnect_task = NULL;
-    }
-  GNUNET_free(h);
+  {
+    GNUNET_SCHEDULER_cancel (h->reconnect_task);
+    h->reconnect_task = NULL;
+  }
+  GNUNET_free (h);
 }
 
 
@@ -602,8 +633,8 @@ GNUNET_ARM_disconnect(struct GNUNET_ARM_Handle *h)
  * @return operation status code
  */
 static enum GNUNET_ARM_Result
-start_arm_service(struct GNUNET_ARM_Handle *h,
-                  enum GNUNET_OS_InheritStdioFlags std_inheritance)
+start_arm_service (struct GNUNET_ARM_Handle *h,
+                   enum GNUNET_OS_InheritStdioFlags std_inheritance)
 {
   struct GNUNET_OS_Process *proc;
   char *cbinary;
@@ -613,98 +644,111 @@ start_arm_service(struct GNUNET_ARM_Handle *h,
   char *loprefix;
   char *lopostfix;
 
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(h->cfg,
-                                                         "arm",
-                                                         "PREFIX",
-                                                         &loprefix))
-    loprefix = GNUNET_strdup("");
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (h->cfg,
+                                                          "arm",
+                                                          "PREFIX",
+                                                          &loprefix))
+    loprefix = GNUNET_strdup ("");
   else
-    loprefix = GNUNET_CONFIGURATION_expand_dollar(h->cfg, loprefix);
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(h->cfg,
-                                                         "arm",
-                                                         "OPTIONS",
-                                                         &lopostfix))
-    lopostfix = GNUNET_strdup("");
+    loprefix = GNUNET_CONFIGURATION_expand_dollar (h->cfg, loprefix);
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (h->cfg,
+                                                          "arm",
+                                                          "OPTIONS",
+                                                          &lopostfix))
+    lopostfix = GNUNET_strdup ("");
   else
-    lopostfix = GNUNET_CONFIGURATION_expand_dollar(h->cfg, lopostfix);
+    lopostfix = GNUNET_CONFIGURATION_expand_dollar (h->cfg,
+                                                    lopostfix);
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string(h->cfg, "arm", "BINARY", &cbinary))
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_WARNING, "arm", "BINARY");
-      GNUNET_free(loprefix);
-      GNUNET_free(lopostfix);
-      return GNUNET_ARM_RESULT_IS_NOT_KNOWN;
-    }
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(h->cfg,
-                                                           "arm",
-                                                           "CONFIG",
-                                                           &config))
+      GNUNET_CONFIGURATION_get_value_string (h->cfg,
+                                             "arm",
+                                             "BINARY",
+                                             &cbinary))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING,
+                               "arm",
+                               "BINARY");
+    GNUNET_free (loprefix);
+    GNUNET_free (lopostfix);
+    return GNUNET_ARM_RESULT_IS_NOT_KNOWN;
+  }
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (h->cfg,
+                                                            "arm",
+                                                            "CONFIG",
+                                                            &config))
     config = NULL;
-  binary = GNUNET_OS_get_libexec_binary_path(cbinary);
-  GNUNET_asprintf(&quotedbinary, "\"%s\"", binary);
-  GNUNET_free(cbinary);
-  if ((GNUNET_YES ==
-       GNUNET_CONFIGURATION_have_value(h->cfg, "TESTING", "WEAKRANDOM")) &&
-      (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(h->cfg,
-                                                          "TESTING",
-                                                          "WEAKRANDOM")) &&
-      (GNUNET_NO ==
-       GNUNET_CONFIGURATION_have_value(h->cfg, "TESTING", "HOSTFILE")))
-    {
-      /* Means we are ONLY running locally */
-      /* we're clearly running a test, don't daemonize */
-      if (NULL == config)
-        proc = GNUNET_OS_start_process_s(GNUNET_NO,
-                                         std_inheritance,
-                                         NULL,
-                                         loprefix,
-                                         quotedbinary,
-                                         /* no daemonization! */
-                                         lopostfix,
-                                         NULL);
-      else
-        proc = GNUNET_OS_start_process_s(GNUNET_NO,
-                                         std_inheritance,
-                                         NULL,
-                                         loprefix,
-                                         quotedbinary,
-                                         "-c",
-                                         config,
-                                         /* no daemonization! */
-                                         lopostfix,
-                                         NULL);
-    }
+  binary = GNUNET_OS_get_libexec_binary_path (cbinary);
+  GNUNET_asprintf (&quotedbinary,
+                   "\"%s\"",
+                   binary);
+  GNUNET_free (cbinary);
+  if ( (GNUNET_YES ==
+        GNUNET_CONFIGURATION_have_value (h->cfg,
+                                         "TESTING",
+                                         "WEAKRANDOM")) &&
+       (GNUNET_YES ==
+        GNUNET_CONFIGURATION_get_value_yesno (h->cfg,
+                                              "TESTING",
+                                              "WEAKRANDOM")) &&
+       (GNUNET_NO ==
+        GNUNET_CONFIGURATION_have_value (h->cfg,
+                                         "TESTING",
+                                         "HOSTFILE")) )
+  {
+    /* Means we are ONLY running locally */
+    /* we're clearly running a test, don't daemonize */
+    if (NULL == config)
+      proc = GNUNET_OS_start_process_s (GNUNET_NO,
+                                        std_inheritance,
+                                        NULL,
+                                        loprefix,
+                                        quotedbinary,
+                                        /* no daemonization! */
+                                        lopostfix,
+                                        NULL);
+    else
+      proc = GNUNET_OS_start_process_s (GNUNET_NO,
+                                        std_inheritance,
+                                        NULL,
+                                        loprefix,
+                                        quotedbinary,
+                                        "-c",
+                                        config,
+                                        /* no daemonization! */
+                                        lopostfix,
+                                        NULL);
+  }
   else
-    {
-      if (NULL == config)
-        proc = GNUNET_OS_start_process_s(GNUNET_NO,
-                                         std_inheritance,
-                                         NULL,
-                                         loprefix,
-                                         quotedbinary,
-                                         "-d", /* do daemonize */
-                                         lopostfix,
-                                         NULL);
-      else
-        proc = GNUNET_OS_start_process_s(GNUNET_NO,
-                                         std_inheritance,
-                                         NULL,
-                                         loprefix,
-                                         quotedbinary,
-                                         "-c",
-                                         config,
-                                         "-d", /* do daemonize */
-                                         lopostfix,
-                                         NULL);
-    }
-  GNUNET_free(binary);
-  GNUNET_free(quotedbinary);
-  GNUNET_free_non_null(config);
-  GNUNET_free(loprefix);
-  GNUNET_free(lopostfix);
+  {
+    if (NULL == config)
+      proc = GNUNET_OS_start_process_s (GNUNET_NO,
+                                        std_inheritance,
+                                        NULL,
+                                        loprefix,
+                                        quotedbinary,
+                                        "-d",  /* do daemonize */
+                                        lopostfix,
+                                        NULL);
+    else
+      proc = GNUNET_OS_start_process_s (GNUNET_NO,
+                                        std_inheritance,
+                                        NULL,
+                                        loprefix,
+                                        quotedbinary,
+                                        "-c",
+                                        config,
+                                        "-d",  /* do daemonize */
+                                        lopostfix,
+                                        NULL);
+  }
+  GNUNET_free (binary);
+  GNUNET_free (quotedbinary);
+  GNUNET_free_non_null (config);
+  GNUNET_free (loprefix);
+  GNUNET_free (lopostfix);
   if (NULL == proc)
     return GNUNET_ARM_RESULT_START_FAILED;
-  GNUNET_OS_process_destroy(proc);
+  GNUNET_OS_process_destroy (proc);
   return GNUNET_ARM_RESULT_STARTING;
 }
 
@@ -716,19 +760,19 @@ start_arm_service(struct GNUNET_ARM_Handle *h,
  * @param op operation to cancel
  */
 void
-GNUNET_ARM_operation_cancel(struct GNUNET_ARM_Operation *op)
+GNUNET_ARM_operation_cancel (struct GNUNET_ARM_Operation *op)
 {
   struct GNUNET_ARM_Handle *h = op->h;
 
   if (h->thm == op)
-    {
-      op->result_cont = NULL;
-      return;
-    }
-  GNUNET_CONTAINER_DLL_remove(h->operation_pending_head,
-                              h->operation_pending_tail,
-                              op);
-  GNUNET_free(op);
+  {
+    op->result_cont = NULL;
+    return;
+  }
+  GNUNET_CONTAINER_DLL_remove (h->operation_pending_head,
+                               h->operation_pending_tail,
+                               op);
+  GNUNET_free (op);
 }
 
 
@@ -743,38 +787,38 @@ GNUNET_ARM_operation_cancel(struct GNUNET_ARM_Operation *op)
  * @return handle to queue, NULL on error
  */
 static struct GNUNET_ARM_Operation *
-change_service(struct GNUNET_ARM_Handle *h,
-               const char *service_name,
-               GNUNET_ARM_ResultCallback cb,
-               void *cb_cls,
-               uint16_t type)
+change_service (struct GNUNET_ARM_Handle *h,
+                const char *service_name,
+                GNUNET_ARM_ResultCallback cb,
+                void *cb_cls,
+                uint16_t type)
 {
   struct GNUNET_ARM_Operation *op;
   size_t slen;
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_ARM_Message *msg;
 
-  slen = strlen(service_name) + 1;
+  slen = strlen (service_name) + 1;
   if (slen + sizeof(struct GNUNET_ARM_Message) >= GNUNET_MAX_MESSAGE_SIZE)
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   if (0 == h->request_id_counter)
     h->request_id_counter++;
-  op = GNUNET_new(struct GNUNET_ARM_Operation);
+  op = GNUNET_new (struct GNUNET_ARM_Operation);
   op->h = h;
   op->result_cont = cb;
   op->cont_cls = cb_cls;
   op->id = h->request_id_counter++;
-  GNUNET_CONTAINER_DLL_insert_tail(h->operation_pending_head,
-                                   h->operation_pending_tail,
-                                   op);
-  env = GNUNET_MQ_msg_extra(msg, slen, type);
-  msg->reserved = htonl(0);
-  msg->request_id = GNUNET_htonll(op->id);
-  GNUNET_memcpy(&msg[1], service_name, slen);
-  GNUNET_MQ_send(h->mq, env);
+  GNUNET_CONTAINER_DLL_insert_tail (h->operation_pending_head,
+                                    h->operation_pending_tail,
+                                    op);
+  env = GNUNET_MQ_msg_extra (msg, slen, type);
+  msg->reserved = htonl (0);
+  msg->request_id = GNUNET_htonll (op->id);
+  GNUNET_memcpy (&msg[1], service_name, slen);
+  GNUNET_MQ_send (h->mq, env);
   return op;
 }
 
@@ -785,22 +829,24 @@ change_service(struct GNUNET_ARM_Handle *h,
  * @param cls the operation that asked ARM to be started
  */
 static void
-notify_running(void *cls)
+notify_running (void *cls)
 {
   struct GNUNET_ARM_Operation *op = cls;
   struct GNUNET_ARM_Handle *h = op->h;
 
   op->async = NULL;
-  GNUNET_CONTAINER_DLL_remove(h->operation_pending_head,
-                              h->operation_pending_tail,
-                              op);
+  GNUNET_CONTAINER_DLL_remove (h->operation_pending_head,
+                               h->operation_pending_tail,
+                               op);
   if (NULL != op->result_cont)
-    op->result_cont(op->cont_cls,
-                    GNUNET_ARM_REQUEST_SENT_OK,
-                    GNUNET_ARM_RESULT_IS_STARTED_ALREADY);
-  if ((GNUNET_YES == h->currently_up) && (NULL != h->conn_status))
-    h->conn_status(h->conn_status_cls, GNUNET_YES);
-  GNUNET_free(op);
+    op->result_cont (op->cont_cls,
+                     GNUNET_ARM_REQUEST_SENT_OK,
+                     GNUNET_ARM_RESULT_IS_STARTED_ALREADY);
+  if ( (GNUNET_YES == h->currently_up) &&
+       (NULL != h->conn_status) )
+    h->conn_status (h->conn_status_cls,
+                    GNUNET_YES);
+  GNUNET_free (op);
 }
 
 
@@ -810,22 +856,22 @@ notify_running(void *cls)
  * @param cls the operation that asked ARM to be started
  */
 static void
-notify_starting(void *cls)
+notify_starting (void *cls)
 {
   struct GNUNET_ARM_Operation *op = cls;
   struct GNUNET_ARM_Handle *h = op->h;
 
   op->async = NULL;
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Notifying client that we started the ARM service\n");
-  GNUNET_CONTAINER_DLL_remove(h->operation_pending_head,
-                              h->operation_pending_tail,
-                              op);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Notifying client that we started the ARM service\n");
+  GNUNET_CONTAINER_DLL_remove (h->operation_pending_head,
+                               h->operation_pending_tail,
+                               op);
   if (NULL != op->result_cont)
-    op->result_cont(op->cont_cls,
-                    GNUNET_ARM_REQUEST_SENT_OK,
-                    op->starting_ret);
-  GNUNET_free(op);
+    op->result_cont (op->cont_cls,
+                     GNUNET_ARM_REQUEST_SENT_OK,
+                     op->starting_ret);
+  GNUNET_free (op);
 }
 
 
@@ -840,23 +886,26 @@ notify_starting(void *cls)
  * @return handle for the operation, NULL on error
  */
 struct GNUNET_ARM_Operation *
-GNUNET_ARM_request_service_start(
-  struct GNUNET_ARM_Handle *h,
-  const char *service_name,
-  enum GNUNET_OS_InheritStdioFlags std_inheritance,
-  GNUNET_ARM_ResultCallback cont,
-  void *cont_cls)
+GNUNET_ARM_request_service_start (struct GNUNET_ARM_Handle *h,
+                                  const char *service_name,
+                                  enum GNUNET_OS_InheritStdioFlags
+                                  std_inheritance,
+                                  GNUNET_ARM_ResultCallback cont,
+                                  void *cont_cls)
 {
   struct GNUNET_ARM_Operation *op;
   enum GNUNET_ARM_Result ret;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "Starting service `%s'\n", service_name);
-  if (0 != strcasecmp("arm", service_name))
-    return change_service(h,
-                          service_name,
-                          cont,
-                          cont_cls,
-                          GNUNET_MESSAGE_TYPE_ARM_START);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Starting service `%s'\n",
+       service_name);
+  if (0 != strcasecmp ("arm",
+                       service_name))
+    return change_service (h,
+                           service_name,
+                           cont,
+                           cont_cls,
+                           GNUNET_MESSAGE_TYPE_ARM_START);
 
   /* Possible cases:
    * 1) We're connected to ARM already. Invoke the callback immediately.
@@ -865,37 +914,39 @@ GNUNET_ARM_request_service_start(
    *    a service test.
    */
   if (GNUNET_YES == h->currently_up)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG, "ARM is already running\n");
-      op = GNUNET_new(struct GNUNET_ARM_Operation);
-      op->h = h;
-      op->result_cont = cont;
-      op->cont_cls = cont_cls;
-      GNUNET_CONTAINER_DLL_insert_tail(h->operation_pending_head,
-                                       h->operation_pending_tail,
-                                       op);
-      op->async = GNUNET_SCHEDULER_add_now(&notify_running, op);
-      return op;
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "ARM is already running\n");
+    op = GNUNET_new (struct GNUNET_ARM_Operation);
+    op->h = h;
+    op->result_cont = cont;
+    op->cont_cls = cont_cls;
+    GNUNET_CONTAINER_DLL_insert_tail (h->operation_pending_head,
+                                      h->operation_pending_tail,
+                                      op);
+    op->async = GNUNET_SCHEDULER_add_now (&notify_running, op);
+    return op;
+  }
   /* This is an inherently uncertain choice, as it is of course
      theoretically possible that ARM is up and we just did not
      yet complete the MQ handshake.  However, given that users
      are unlikely to hammer 'gnunet-arm -s' on a busy system,
      the above check should catch 99.99% of the cases where ARM
      is already running. */
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "Starting ARM service\n");
-  ret = start_arm_service(h, std_inheritance);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Starting ARM service\n");
+  ret = start_arm_service (h, std_inheritance);
   if (GNUNET_ARM_RESULT_STARTING == ret)
-    reconnect_arm(h);
-  op = GNUNET_new(struct GNUNET_ARM_Operation);
+    reconnect_arm (h);
+  op = GNUNET_new (struct GNUNET_ARM_Operation);
   op->h = h;
   op->result_cont = cont;
   op->cont_cls = cont_cls;
-  GNUNET_CONTAINER_DLL_insert_tail(h->operation_pending_head,
-                                   h->operation_pending_tail,
-                                   op);
+  GNUNET_CONTAINER_DLL_insert_tail (h->operation_pending_head,
+                                    h->operation_pending_tail,
+                                    op);
   op->starting_ret = ret;
-  op->async = GNUNET_SCHEDULER_add_now(&notify_starting, op);
+  op->async = GNUNET_SCHEDULER_add_now (&notify_starting,
+                                        op);
   return op;
 }
 
@@ -915,24 +966,27 @@ GNUNET_ARM_request_service_start(
  * @return handle for the operation, NULL on error
  */
 struct GNUNET_ARM_Operation *
-GNUNET_ARM_request_service_stop(struct GNUNET_ARM_Handle *h,
-                                const char *service_name,
-                                GNUNET_ARM_ResultCallback cont,
-                                void *cont_cls)
+GNUNET_ARM_request_service_stop (struct GNUNET_ARM_Handle *h,
+                                 const char *service_name,
+                                 GNUNET_ARM_ResultCallback cont,
+                                 void *cont_cls)
 {
   struct GNUNET_ARM_Operation *op;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "Stopping service `%s'\n", service_name);
-  op = change_service(h,
-                      service_name,
-                      cont,
-                      cont_cls,
-                      GNUNET_MESSAGE_TYPE_ARM_STOP);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Stopping service `%s'\n",
+       service_name);
+  op = change_service (h,
+                       service_name,
+                       cont,
+                       cont_cls,
+                       GNUNET_MESSAGE_TYPE_ARM_STOP);
   if (NULL == op)
     return NULL;
   /* If the service is ARM, set a flag as we will use MQ errors
      to detect that the process is really gone. */
-  if (0 == strcasecmp(service_name, "arm"))
+  if (0 == strcasecmp (service_name,
+                       "arm"))
     op->is_arm_stop = GNUNET_YES;
   return op;
 }
@@ -947,29 +1001,31 @@ GNUNET_ARM_request_service_stop(struct GNUNET_ARM_Handle *h,
  * @return handle for the operation, NULL on error
  */
 struct GNUNET_ARM_Operation *
-GNUNET_ARM_request_service_list(struct GNUNET_ARM_Handle *h,
-                                GNUNET_ARM_ServiceListCallback cont,
-                                void *cont_cls)
+GNUNET_ARM_request_service_list (struct GNUNET_ARM_Handle *h,
+                                 GNUNET_ARM_ServiceListCallback cont,
+                                 void *cont_cls)
 {
   struct GNUNET_ARM_Operation *op;
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_ARM_Message *msg;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "Requesting LIST from ARM service\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Requesting LIST from ARM service\n");
   if (0 == h->request_id_counter)
     h->request_id_counter++;
-  op = GNUNET_new(struct GNUNET_ARM_Operation);
+  op = GNUNET_new (struct GNUNET_ARM_Operation);
   op->h = h;
   op->list_cont = cont;
   op->cont_cls = cont_cls;
   op->id = h->request_id_counter++;
-  GNUNET_CONTAINER_DLL_insert_tail(h->operation_pending_head,
-                                   h->operation_pending_tail,
-                                   op);
-  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_ARM_LIST);
-  msg->reserved = htonl(0);
-  msg->request_id = GNUNET_htonll(op->id);
-  GNUNET_MQ_send(h->mq, env);
+  GNUNET_CONTAINER_DLL_insert_tail (h->operation_pending_head,
+                                    h->operation_pending_tail,
+                                    op);
+  env = GNUNET_MQ_msg (msg,
+                       GNUNET_MESSAGE_TYPE_ARM_LIST);
+  msg->reserved = htonl (0);
+  msg->request_id = GNUNET_htonll (op->id);
+  GNUNET_MQ_send (h->mq, env);
   return op;
 }