X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Farm%2Farm_api.c;h=15563e93398b840d64cf6ed0e3b53b50fbc6e66b;hb=d0b4927e6ab7e8b9874dd7807055e77fb4c5163f;hp=f61eea6fda5111e008eb96257ee297050c18c083;hpb=f777b26daef27327d4ef692cef1612d5d30ae0ea;p=oweals%2Fgnunet.git

diff --git a/src/arm/arm_api.c b/src/arm/arm_api.c
index f61eea6fd..15563e933 100644
--- a/src/arm/arm_api.c
+++ b/src/arm/arm_api.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2009, 2010 Christian Grothoff (and other contributing authors)
+     (C) 2009, 2010, 2012 Christian Grothoff (and other contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -25,11 +25,8 @@
  */
 #include "platform.h"
 #include "gnunet_arm_service.h"
-#include "gnunet_client_lib.h"
-#include "gnunet_getopt_lib.h"
-#include "gnunet_os_lib.h"
+#include "gnunet_util_lib.h"
 #include "gnunet_protocols.h"
-#include "gnunet_server_lib.h"
 #include "arm.h"
 
 #define LOG(kind,...) GNUNET_log_from (kind, "arm-api",__VA_ARGS__)
@@ -52,7 +49,6 @@ struct GNUNET_ARM_Handle
 
 };
 
-
 /**
  * Context for handling the shutdown of a service.
  */
@@ -84,12 +80,13 @@ struct ShutdownContext
   void *cont_cls;
 
   /**
-   * We received a confirmation that the service will shut down.
+   * Handle for transmission request.
    */
-  int confirmed;
+  struct GNUNET_CLIENT_TransmitHandle *th;
 
 };
 
+
 /**
  * Handler receiving response to service shutdown requests.
  * First call with NULL: service misbehaving, or something.
@@ -106,76 +103,39 @@ service_shutdown_handler (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct ShutdownContext *shutdown_ctx = cls;
 
-  if ((msg == NULL) && (shutdown_ctx->confirmed != GNUNET_YES))
+  if (NULL != msg)
   {
-#if DEBUG_ARM
-    /* Means the other side closed the connection and never confirmed a shutdown */
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Service handle shutdown before ACK!\n");
-#endif
-    if (shutdown_ctx->cont != NULL)
-      shutdown_ctx->cont (shutdown_ctx->cont_cls, GNUNET_SYSERR);
-    GNUNET_SCHEDULER_cancel (shutdown_ctx->cancel_task);
-    GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
-    GNUNET_free (shutdown_ctx);
-  }
-  else if ((msg == NULL) && (shutdown_ctx->confirmed == GNUNET_YES))
-  {
-#if DEBUG_ARM
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Service shutdown complete.\n");
-#endif
-    if (shutdown_ctx->cont != NULL)
-      shutdown_ctx->cont (shutdown_ctx->cont_cls, GNUNET_NO);
-
+    /* We just expected a disconnect! Report the error and be done with it... */
+    GNUNET_break (0);
+    shutdown_ctx->cont (shutdown_ctx->cont_cls, GNUNET_ARM_PROCESS_COMMUNICATION_ERROR);
     GNUNET_SCHEDULER_cancel (shutdown_ctx->cancel_task);
-    GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
+    GNUNET_CLIENT_disconnect (shutdown_ctx->sock);
     GNUNET_free (shutdown_ctx);
+    return;
   }
-  else
-  {
-    GNUNET_assert (ntohs (msg->size) == sizeof (struct GNUNET_MessageHeader));
-    switch (ntohs (msg->type))
-    {
-    case GNUNET_MESSAGE_TYPE_ARM_SHUTDOWN_ACK:
-#if DEBUG_ARM
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Received confirmation for service shutdown.\n");
-#endif
-      shutdown_ctx->confirmed = GNUNET_YES;
-      GNUNET_CLIENT_receive (shutdown_ctx->sock, &service_shutdown_handler,
-                             shutdown_ctx, GNUNET_TIME_UNIT_FOREVER_REL);
-      break;
-    default:                   /* Fall through */
-#if DEBUG_ARM
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "Service shutdown refused!\n");
-#endif
-      if (shutdown_ctx->cont != NULL)
-        shutdown_ctx->cont (shutdown_ctx->cont_cls, GNUNET_YES);
-
-      GNUNET_SCHEDULER_cancel (shutdown_ctx->cancel_task);
-      GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
-      GNUNET_free (shutdown_ctx);
-      break;
-    }
-  }
+  if (NULL != shutdown_ctx->cont)
+    /* shutdown is now complete, as we waited for the network disconnect... */
+    shutdown_ctx->cont (shutdown_ctx->cont_cls, GNUNET_ARM_PROCESS_DOWN);    
+  GNUNET_SCHEDULER_cancel (shutdown_ctx->cancel_task);
+  GNUNET_CLIENT_disconnect (shutdown_ctx->sock);
+  GNUNET_free (shutdown_ctx);
 }
 
+
 /**
  * Shutting down took too long, cancel receive and return error.
  *
  * @param cls closure
  * @param tc context information (why was this task triggered now)
  */
-void
+static void
 service_shutdown_cancel (void *cls,
-                         const struct GNUNET_SCHEDULER_TaskContext *tc)
+			 const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct ShutdownContext *shutdown_ctx = cls;
 
-#if DEBUG_ARM
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "service_shutdown_cancel called!\n");
-#endif
-  shutdown_ctx->cont (shutdown_ctx->cont_cls, GNUNET_SYSERR);
-  GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
+  shutdown_ctx->cont (shutdown_ctx->cont_cls, GNUNET_ARM_PROCESS_COMMUNICATION_TIMEOUT);
+  GNUNET_CLIENT_disconnect (shutdown_ctx->sock);
   GNUNET_free (shutdown_ctx);
 }
 
@@ -192,25 +152,25 @@ service_shutdown_cancel (void *cls,
 static size_t
 write_shutdown (void *cls, size_t size, void *buf)
 {
-  struct GNUNET_MessageHeader *msg;
   struct ShutdownContext *shutdown_ctx = cls;
+  struct GNUNET_MessageHeader *msg;
 
+  shutdown_ctx->th = NULL;
   if (size < sizeof (struct GNUNET_MessageHeader))
   {
     LOG (GNUNET_ERROR_TYPE_WARNING,
-         _("Failed to transmit shutdown request to client.\n"));
-    shutdown_ctx->cont (shutdown_ctx->cont_cls, GNUNET_SYSERR);
-    GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
+	 _("Failed to transmit shutdown request to client.\n"));
+    shutdown_ctx->cont (shutdown_ctx->cont_cls, GNUNET_ARM_PROCESS_COMMUNICATION_ERROR);
+    GNUNET_CLIENT_disconnect (shutdown_ctx->sock);
     GNUNET_free (shutdown_ctx);
-    return 0;                   /* client disconnected */
+    return 0;			/* client disconnected */
   }
-
   GNUNET_CLIENT_receive (shutdown_ctx->sock, &service_shutdown_handler,
-                         shutdown_ctx, GNUNET_TIME_UNIT_FOREVER_REL);
+			 shutdown_ctx, GNUNET_TIME_UNIT_FOREVER_REL);
   shutdown_ctx->cancel_task =
-      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining
-                                    (shutdown_ctx->timeout),
-                                    &service_shutdown_cancel, shutdown_ctx);
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining
+				  (shutdown_ctx->timeout),
+				  &service_shutdown_cancel, shutdown_ctx);
   msg = (struct GNUNET_MessageHeader *) buf;
   msg->type = htons (GNUNET_MESSAGE_TYPE_ARM_SHUTDOWN);
   msg->size = htons (sizeof (struct GNUNET_MessageHeader));
@@ -233,8 +193,8 @@ write_shutdown (void *cls, size_t size, void *buf)
  */
 static void
 arm_service_shutdown (struct GNUNET_CLIENT_Connection *sock,
-                      struct GNUNET_TIME_Relative timeout,
-                      GNUNET_CLIENT_ShutdownTask cont, void *cont_cls)
+		      struct GNUNET_TIME_Relative timeout,
+		      GNUNET_CLIENT_ShutdownTask cont, void *cont_cls)
 {
   struct ShutdownContext *shutdown_ctx;
 
@@ -243,10 +203,10 @@ arm_service_shutdown (struct GNUNET_CLIENT_Connection *sock,
   shutdown_ctx->cont_cls = cont_cls;
   shutdown_ctx->sock = sock;
   shutdown_ctx->timeout = GNUNET_TIME_relative_to_absolute (timeout);
-  GNUNET_CLIENT_notify_transmit_ready (sock,
-                                       sizeof (struct GNUNET_MessageHeader),
-                                       timeout, GNUNET_YES, &write_shutdown,
-                                       shutdown_ctx);
+  shutdown_ctx->th = GNUNET_CLIENT_notify_transmit_ready (sock,
+							  sizeof (struct GNUNET_MessageHeader),
+							  timeout, GNUNET_NO, &write_shutdown,
+							  shutdown_ctx);
 }
 
 
@@ -262,7 +222,7 @@ arm_service_shutdown (struct GNUNET_CLIENT_Connection *sock,
  */
 struct GNUNET_ARM_Handle *
 GNUNET_ARM_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                    const char *service)
+		    const char *service)
 {
   struct GNUNET_ARM_Handle *ret;
 
@@ -281,11 +241,12 @@ void
 GNUNET_ARM_disconnect (struct GNUNET_ARM_Handle *h)
 {
   if (h->client != NULL)
-    GNUNET_CLIENT_disconnect (h->client, GNUNET_NO);
+    GNUNET_CLIENT_disconnect (h->client);
   GNUNET_CONFIGURATION_destroy (h->cfg);
   GNUNET_free (h);
 }
 
+
 struct ARM_ShutdownContext
 {
   /**
@@ -300,7 +261,6 @@ struct ARM_ShutdownContext
 };
 
 
-
 /**
  * Internal state for a request with ARM.
  */
@@ -332,6 +292,11 @@ struct RequestContext
    */
   uint16_t type;
 
+  /**
+   * Flags for passing std descriptors to ARM (when starting ARM).
+   */
+  enum GNUNET_OS_InheritStdioFlags std_inheritance;
+
 };
 
 #include "do_start_process.c"
@@ -358,38 +323,33 @@ arm_service_report (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
   {
-#if DEBUG_ARM
     LOG (GNUNET_ERROR_TYPE_DEBUG, "Looks like `%s' is already running.\n",
-         "gnunet-service-arm");
-#endif
+	 "gnunet-service-arm");
     /* arm is running! */
     if (pos->callback != NULL)
-      pos->callback (pos->cls, GNUNET_YES);
+      pos->callback (pos->cls, GNUNET_ARM_PROCESS_ALREADY_RUNNING);
     GNUNET_free (pos);
     return;
   }
-#if DEBUG_ARM
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Looks like `%s' is not running, will start it.\n",
        "gnunet-service-arm");
-#endif
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_string (pos->h->cfg, "arm", "PREFIX",
-                                             &loprefix))
+					     &loprefix))
     loprefix = GNUNET_strdup ("");
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_string (pos->h->cfg, "arm", "OPTIONS",
-                                             &lopostfix))
+					     &lopostfix))
     lopostfix = GNUNET_strdup ("");
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_string (pos->h->cfg, "arm", "BINARY",
-                                             &binary))
+					     &binary))
   {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _("Configuration failes to specify option `%s' in section `%s'!\n"),
-         "BINARY", "arm");
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING,
+			       "arm", "BINARY");
     if (pos->callback != NULL)
-      pos->callback (pos->cls, GNUNET_SYSERR);
+      pos->callback (pos->cls, GNUNET_ARM_PROCESS_UNKNOWN);
     GNUNET_free (pos);
     GNUNET_free (loprefix);
     GNUNET_free (lopostfix);
@@ -397,51 +357,53 @@ arm_service_report (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   }
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_filename (pos->h->cfg, "arm", "CONFIG",
-                                               &config))
+					       &config))
   {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _("Configuration fails to specify option `%s' in section `%s'!\n"),
-         "CONFIG", "arm");
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING,
+			       "arm", "CONFIG");
     if (pos->callback != NULL)
-      pos->callback (pos->cls, GNUNET_SYSERR);
+      pos->callback (pos->cls, GNUNET_ARM_PROCESS_UNKNOWN);
     GNUNET_free (binary);
     GNUNET_free (pos);
     GNUNET_free (loprefix);
     GNUNET_free (lopostfix);
     return;
   }
-  if ((GNUNET_YES == GNUNET_CONFIGURATION_have_value (pos->h->cfg, "TESTING", "WEAKRANDOM")) && (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (pos->h->cfg, "TESTING", "WEAKRANDOM")) && (GNUNET_NO == GNUNET_CONFIGURATION_have_value (pos->h->cfg, "TESTING", "HOSTFILE"))      /* Means we are ONLY running locally */
-      )
+  if ((GNUNET_YES ==
+       GNUNET_CONFIGURATION_have_value (pos->h->cfg, "TESTING", "WEAKRANDOM"))
+      && (GNUNET_YES ==
+	  GNUNET_CONFIGURATION_get_value_yesno (pos->h->cfg, "TESTING",
+						"WEAKRANDOM"))
+      && (GNUNET_NO ==
+	  GNUNET_CONFIGURATION_have_value (pos->h->cfg, "TESTING",
+					   "HOSTFILE")))
   {
+    /* Means we are ONLY running locally */
     /* we're clearly running a test, don't daemonize */
-    proc = do_start_process (NULL, loprefix, binary, "-c", config,
-#if DEBUG_ARM
-                             "-L", "DEBUG",
-#endif
-                             /* no daemonization! */
-                             lopostfix, NULL);
+    proc = do_start_process (GNUNET_NO, pos->std_inheritance,
+			     NULL, loprefix, binary, "-c", config,
+			     /* no daemonization! */
+			     lopostfix, NULL);
   }
   else
   {
-    proc = do_start_process (NULL, loprefix, binary, "-c", config,
-#if DEBUG_ARM
-                             "-L", "DEBUG",
-#endif
-                             "-d", lopostfix, NULL);
+    proc = do_start_process (GNUNET_NO, pos->std_inheritance,
+			     NULL, loprefix, binary, "-c", config,
+			     "-d", lopostfix, NULL);
   }
   GNUNET_free (binary);
   GNUNET_free (config);
   GNUNET_free (loprefix);
   GNUNET_free (lopostfix);
   if (proc == NULL)
-  {
-    if (pos->callback != NULL)
-      pos->callback (pos->cls, GNUNET_SYSERR);
-    GNUNET_free (pos);
-    return;
-  }
+    {
+      if (pos->callback != NULL)
+	pos->callback (pos->cls, GNUNET_ARM_PROCESS_FAILURE);
+      GNUNET_free (pos);
+      return;
+    }
   if (pos->callback != NULL)
-    pos->callback (pos->cls, GNUNET_YES);
+    pos->callback (pos->cls, GNUNET_ARM_PROCESS_STARTING);
   GNUNET_free (proc);
   GNUNET_free (pos);
 }
@@ -458,46 +420,28 @@ static void
 handle_response (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct RequestContext *sc = cls;
-  int ret;
+  const struct GNUNET_ARM_ResultMessage *res;
+  enum GNUNET_ARM_ProcessStatus status;
 
-  if (msg == NULL)
+  if ((msg == NULL) ||
+      (ntohs (msg->size) != sizeof (struct GNUNET_ARM_ResultMessage)))
   {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _
-         ("Error receiving response to `%s' request from ARM for service `%s'\n"),
-         (sc->type == GNUNET_MESSAGE_TYPE_ARM_START) ? "START" : "STOP",
-         (const char *) &sc[1]);
-    GNUNET_CLIENT_disconnect (sc->h->client, GNUNET_NO);
+    GNUNET_break (0);
+    GNUNET_CLIENT_disconnect (sc->h->client);
     sc->h->client = GNUNET_CLIENT_connect ("arm", sc->h->cfg);
     GNUNET_assert (NULL != sc->h->client);
-    GNUNET_CLIENT_ignore_shutdown (sc->h->client, GNUNET_YES);
     if (sc->callback != NULL)
-      sc->callback (sc->cls, GNUNET_SYSERR);
+      sc->callback (sc->cls, GNUNET_ARM_PROCESS_COMMUNICATION_ERROR);
     GNUNET_free (sc);
     return;
   }
-#if DEBUG_ARM
+  res = (const struct GNUNET_ARM_ResultMessage *) msg;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Received response from ARM for service `%s': %u\n",
        (const char *) &sc[1], ntohs (msg->type));
-#endif
-  switch (ntohs (msg->type))
-  {
-  case GNUNET_MESSAGE_TYPE_ARM_IS_UP:
-    ret = GNUNET_YES;
-    break;
-  case GNUNET_MESSAGE_TYPE_ARM_IS_DOWN:
-    ret = GNUNET_NO;
-    break;
-  case GNUNET_MESSAGE_TYPE_ARM_IS_UNKNOWN:
-    ret = GNUNET_SYSERR;
-    break;
-  default:
-    GNUNET_break (0);
-    ret = GNUNET_SYSERR;
-  }
+  status = (enum GNUNET_ARM_ProcessStatus) ntohl (res->status);
   if (sc->callback != NULL)
-    sc->callback (sc->cls, ret);
+    sc->callback (sc->cls, status);
   GNUNET_free (sc);
 }
 
@@ -514,8 +458,8 @@ handle_response (void *cls, const struct GNUNET_MessageHeader *msg)
  */
 static void
 change_service (struct GNUNET_ARM_Handle *h, const char *service_name,
-                struct GNUNET_TIME_Relative timeout, GNUNET_ARM_Callback cb,
-                void *cb_cls, uint16_t type)
+		struct GNUNET_TIME_Relative timeout, GNUNET_ARM_Callback cb,
+		void *cb_cls, uint16_t type)
 {
   struct RequestContext *sctx;
   size_t slen;
@@ -530,13 +474,11 @@ change_service (struct GNUNET_ARM_Handle *h, const char *service_name,
       cb (cb_cls, GNUNET_NO);
     return;
   }
-#if DEBUG_ARM
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        (type ==
-        GNUNET_MESSAGE_TYPE_ARM_START) ?
-       _("Requesting start of service `%s'.\n") :
-       _("Requesting termination of service `%s'.\n"), service_name);
-#endif
+	GNUNET_MESSAGE_TYPE_ARM_START) ?
+       "Requesting start of service `%s'.\n" :
+       "Requesting termination of service `%s'.\n", service_name);
   sctx = GNUNET_malloc (sizeof (struct RequestContext) + slen);
   sctx->h = h;
   sctx->callback = cb;
@@ -550,16 +492,11 @@ change_service (struct GNUNET_ARM_Handle *h, const char *service_name,
   memcpy (&msg[1], service_name, slen);
   if (GNUNET_OK !=
       GNUNET_CLIENT_transmit_and_get_response (sctx->h->client, msg,
-                                               GNUNET_TIME_absolute_get_remaining
-                                               (sctx->timeout), GNUNET_YES,
-                                               &handle_response, sctx))
+					       GNUNET_TIME_absolute_get_remaining
+					       (sctx->timeout), GNUNET_YES,
+					       &handle_response, sctx))
   {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         (type ==
-          GNUNET_MESSAGE_TYPE_ARM_START) ?
-         _("Error while trying to transmit request to start `%s' to ARM\n") :
-         _("Error while trying to transmit request to stop `%s' to ARM\n"),
-         (const char *) &service_name);
+    GNUNET_break (0);
     if (cb != NULL)
       cb (cb_cls, GNUNET_SYSERR);
     GNUNET_free (sctx);
@@ -575,24 +512,25 @@ change_service (struct GNUNET_ARM_Handle *h, const char *service_name,
  *
  * @param h handle to ARM
  * @param service_name name of the service
+ * @param std_inheritance inheritance of std streams
  * @param timeout how long to wait before failing for good
  * @param cb callback to invoke when service is ready
  * @param cb_cls closure for callback
  */
 void
-GNUNET_ARM_start_service (struct GNUNET_ARM_Handle *h, const char *service_name,
-                          struct GNUNET_TIME_Relative timeout,
-                          GNUNET_ARM_Callback cb, void *cb_cls)
+GNUNET_ARM_start_service (struct GNUNET_ARM_Handle *h,
+			  const char *service_name,
+                          enum GNUNET_OS_InheritStdioFlags std_inheritance,
+			  struct GNUNET_TIME_Relative timeout,
+			  GNUNET_ARM_Callback cb, void *cb_cls)
 {
   struct RequestContext *sctx;
   struct GNUNET_CLIENT_Connection *client;
   size_t slen;
 
-#if DEBUG_ARM
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       _("Asked to start service `%s' within %llu ms\n"), service_name,
-       (unsigned long long) timeout.rel_value);
-#endif
+       "Asked to start service `%s' within %s\n", service_name,
+       GNUNET_STRINGS_relative_time_to_string (timeout, GNUNET_NO));
   if (0 == strcasecmp ("arm", service_name))
   {
     slen = strlen ("arm") + 1;
@@ -601,47 +539,46 @@ GNUNET_ARM_start_service (struct GNUNET_ARM_Handle *h, const char *service_name,
     sctx->callback = cb;
     sctx->cls = cb_cls;
     sctx->timeout = GNUNET_TIME_relative_to_absolute (timeout);
+    sctx->std_inheritance = std_inheritance;
     memcpy (&sctx[1], service_name, slen);
     GNUNET_CLIENT_service_test ("arm", h->cfg, timeout, &arm_service_report,
-                                sctx);
+				sctx);
     return;
   }
-  if (h->client == NULL)
+  if (NULL == h->client)
   {
     client = GNUNET_CLIENT_connect ("arm", h->cfg);
     if (client == NULL)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "arm_api, GNUNET_CLIENT_connect returned NULL\n");
-      cb (cb_cls, GNUNET_SYSERR);
+	   "arm_api, GNUNET_CLIENT_connect returned NULL\n");
+      cb (cb_cls, GNUNET_ARM_PROCESS_COMMUNICATION_ERROR);
       return;
     }
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "arm_api, GNUNET_CLIENT_connect returned non-NULL\n");
-    GNUNET_CLIENT_ignore_shutdown (client, GNUNET_YES);
+	 "arm_api, GNUNET_CLIENT_connect returned non-NULL\n");
     h->client = client;
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG, "arm_api, h->client non-NULL\n");
   change_service (h, service_name, timeout, cb, cb_cls,
-                  GNUNET_MESSAGE_TYPE_ARM_START);
+		  GNUNET_MESSAGE_TYPE_ARM_START);
 }
 
+
 /**
  * Callback from the arm stop service call, indicates that the arm service
  * is well and truly dead, won't die, or an error occurred.
  *
  * @param cls closure for the callback
- * @param reason reason for callback, GNUNET_NO if arm is shutdown
- *        GNUNET_YES if arm remains running, and GNUNET_SYSERR on error
+ * @param reason reason for callback
  */
-void
-arm_shutdown_callback (void *cls, int reason)
+static void
+arm_shutdown_callback (void *cls, enum GNUNET_ARM_ProcessStatus reason)
 {
   struct ARM_ShutdownContext *arm_shutdown_ctx = cls;
 
   if (arm_shutdown_ctx->cb != NULL)
     arm_shutdown_ctx->cb (arm_shutdown_ctx->cb_cls, reason);
-
   GNUNET_free (arm_shutdown_ctx);
 }
 
@@ -656,15 +593,18 @@ arm_shutdown_callback (void *cls, int reason)
  * @param cb_cls closure for callback
  */
 void
-GNUNET_ARM_stop_service (struct GNUNET_ARM_Handle *h, const char *service_name,
-                         struct GNUNET_TIME_Relative timeout,
-                         GNUNET_ARM_Callback cb, void *cb_cls)
+GNUNET_ARM_stop_service (struct GNUNET_ARM_Handle *h,
+			 const char *service_name,
+			 struct GNUNET_TIME_Relative timeout,
+			 GNUNET_ARM_Callback cb, void *cb_cls)
 {
   struct ARM_ShutdownContext *arm_shutdown_ctx;
   struct GNUNET_CLIENT_Connection *client;
 
-  LOG (GNUNET_ERROR_TYPE_INFO, _("Stopping service `%s' within %llu ms\n"),
-       service_name, (unsigned long long) timeout.rel_value);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, 
+       "Stopping service `%s' within %s\n",
+       service_name, 
+       GNUNET_STRINGS_relative_time_to_string (timeout, GNUNET_NO));
   if (h->client == NULL)
   {
     client = GNUNET_CLIENT_connect ("arm", h->cfg);
@@ -673,7 +613,6 @@ GNUNET_ARM_stop_service (struct GNUNET_ARM_Handle *h, const char *service_name,
       cb (cb_cls, GNUNET_SYSERR);
       return;
     }
-    GNUNET_CLIENT_ignore_shutdown (client, GNUNET_YES);
     h->client = client;
   }
   if (0 == strcasecmp ("arm", service_name))
@@ -682,13 +621,170 @@ GNUNET_ARM_stop_service (struct GNUNET_ARM_Handle *h, const char *service_name,
     arm_shutdown_ctx->cb = cb;
     arm_shutdown_ctx->cb_cls = cb_cls;
     arm_service_shutdown (h->client, timeout, &arm_shutdown_callback,
-                          arm_shutdown_ctx);
+			  arm_shutdown_ctx);
     h->client = NULL;
     return;
   }
   change_service (h, service_name, timeout, cb, cb_cls,
-                  GNUNET_MESSAGE_TYPE_ARM_STOP);
+		  GNUNET_MESSAGE_TYPE_ARM_STOP);
 }
 
 
+/**
+ * Internal state for a list request with ARM.
+ */
+struct ListRequestContext
+{
+
+  /**
+   * Pointer to our handle with ARM.
+   */
+  struct GNUNET_ARM_Handle *h;
+
+  /**
+   * Function to call with a status code for the requested operation.
+   */
+  GNUNET_ARM_List_Callback callback;
+
+  /**
+   * Closure for "callback".
+   */
+  void *cls;
+
+  /**
+   * Timeout for the operation.
+   */
+  struct GNUNET_TIME_Absolute timeout;
+};
+
+
+/**
+ * Process a response from ARM for the list request.
+ *
+ * @param cls the list request context
+ * @param msg the response
+ */
+static void
+handle_list_response (void *cls, const struct GNUNET_MessageHeader *msg)
+{
+  struct ListRequestContext *sc = cls;
+  const struct GNUNET_ARM_ListResultMessage *res;
+  const char *pos;
+  uint16_t size_check;
+  uint16_t rcount;
+  uint16_t msize;
+  
+  if (NULL == msg)
+  {
+    GNUNET_break (0);
+    GNUNET_CLIENT_disconnect (sc->h->client);
+    sc->h->client = GNUNET_CLIENT_connect ("arm", sc->h->cfg);
+    GNUNET_assert (NULL != sc->h->client);
+    if (sc->callback != NULL)
+      sc->callback (sc->cls, GNUNET_ARM_PROCESS_COMMUNICATION_ERROR, 0, NULL);
+    GNUNET_free (sc);
+    return;
+  }
+   
+  if (NULL == sc->callback) 
+  {
+    GNUNET_break (0);
+    GNUNET_free (sc);
+    return;
+  }  
+  msize = ntohs (msg->size);
+  if ( (msize < sizeof ( struct GNUNET_ARM_ListResultMessage)) ||
+       (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT) )
+  {
+    GNUNET_break (0);
+    sc->callback (sc->cls, GNUNET_NO, 0, NULL);
+    GNUNET_free (sc);
+    return;
+  }
+  size_check = 0;
+  res = (const struct GNUNET_ARM_ListResultMessage *) msg;
+  rcount = ntohs (res->count);
+  {
+    const char *list[rcount];
+    unsigned int i;
+    
+    pos = (const char *)&res[1];   
+    for (i=0; i<rcount; i++)
+    {
+      const char *end = memchr (pos, 0, msize - size_check);
+      if (NULL == end)
+      {
+	GNUNET_break (0);
+	sc->callback (sc->cls, GNUNET_NO, 0, NULL);
+	GNUNET_free (sc);
+	return;
+      }
+      list[i] = pos;
+      size_check += (end - pos) + 1;
+      pos = end + 1;
+    }
+    sc->callback (sc->cls, GNUNET_YES, rcount, list);
+  }
+  GNUNET_free (sc);
+}
+
+
+/**
+ * List all running services.
+ * 
+ * @param h handle to ARM
+ * @param timeout how long to wait before failing for good
+ * @param cb callback to invoke when service is ready
+ * @param cb_cls closure for callback
+ */
+void
+GNUNET_ARM_list_running_services (struct GNUNET_ARM_Handle *h,
+                                  struct GNUNET_TIME_Relative timeout,
+                                  GNUNET_ARM_List_Callback cb, void *cb_cls)
+{
+  struct ListRequestContext *sctx;
+  struct GNUNET_MessageHeader msg;
+  struct GNUNET_CLIENT_Connection *client;
+  
+  if (h->client == NULL)
+  {
+    client = GNUNET_CLIENT_connect ("arm", h->cfg);
+    if (client == NULL)
+    {
+      GNUNET_break (0);
+      cb (cb_cls, GNUNET_ARM_PROCESS_COMMUNICATION_ERROR, 0, NULL);
+      return;
+    }
+    h->client = client;
+  }
+  
+  sctx = GNUNET_malloc (sizeof (struct RequestContext));
+  sctx->h = h;
+  sctx->callback = cb;
+  sctx->cls = cb_cls;
+  sctx->timeout = GNUNET_TIME_relative_to_absolute (timeout);
+  msg.size = htons (sizeof (struct GNUNET_MessageHeader));
+  msg.type = htons (GNUNET_MESSAGE_TYPE_ARM_LIST);
+  
+  LOG (GNUNET_ERROR_TYPE_DEBUG, 
+       "Requesting LIST from ARM service with timeout: %s\n", 
+       GNUNET_STRINGS_relative_time_to_string (timeout, GNUNET_YES));
+  
+  if (GNUNET_OK !=
+      GNUNET_CLIENT_transmit_and_get_response (sctx->h->client, 
+                                               &msg,
+                                               GNUNET_TIME_absolute_get_remaining
+                                               (sctx->timeout), 
+                                               GNUNET_YES,
+                                               &handle_list_response, 
+                                               sctx))
+  {
+    GNUNET_break (0);
+    if (cb != NULL)
+      cb (cb_cls, GNUNET_SYSERR, 0, NULL);
+    GNUNET_free (sctx);
+    return;
+  }
+}
+
 /* end of arm_api.c */