-cleaning up client api to test for service availability

12 files changed, 363 insertions, 200 deletions

diff --git a/src/arm/arm_api.c b/src/arm/arm_api.c
index 4ef6b3c27..34f7a6704 100644
--- a/src/arm/arm_api.c
+++ b/src/arm/arm_api.c
@@ -743,10 +743,11 @@ control_message_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *t
  * it is not, start the ARM process.
  *
  * @param cls the context for the request that we will report on (struct ARMControlMessage *)
- * @param tc why were we called (reason says if ARM is running)
+ * @param result GNUNET_YES if ARM is running
  */
 static void
-arm_service_report (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+arm_service_report (void *cls,
+                    int result)
 {
   struct ARMControlMessage *cm = cls;
   struct GNUNET_ARM_Handle *h;
@@ -759,12 +760,11 @@ arm_service_report (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   char *lopostfix;
 
   test_is_active = cm->h->service_test_is_active;
-
-  /* FIXME: shouldn't we check for GNUNET_SCHEDULER_REASON_SHUTDOWN ? */
   if ((GNUNET_YES == test_is_active) &&
-      (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE)))
+      (GNUNET_YES == result))
   {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Looks like `%s' is already running.\n",
+    LOG (GNUNET_ERROR_TYPE_DEBUG, 
+         "Looks like `%s' is already running.\n",
          "gnunet-service-arm");
     /* arm is running! */
     if (cm->result_cont)
@@ -780,7 +780,7 @@ arm_service_report (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     GNUNET_CONFIGURATION_destroy (cm->h->cfg);
     GNUNET_free (cm->h);
   }
-  if ((0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE)) ||
+  if ((GNUNET_YES == result) ||
       (GNUNET_NO == test_is_active))
   {
     GNUNET_free (cm);
diff --git a/src/ats-tool/gnunet-ats.c b/src/ats-tool/gnunet-ats.c
index 2e61247bb..f8ecd3aad 100644
--- a/src/ats-tool/gnunet-ats.c
+++ b/src/ats-tool/gnunet-ats.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2001, 2002, 2004, 2005, 2006, 2007, 2009 Christian Grothoff (and other contributing authors)
+     (C) 2009--2013 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
@@ -80,14 +80,14 @@ static int op_print_quotas;
 static int op_monitor;
 
 
-
 static struct GNUNET_ATS_PerformanceHandle *ph;
 
-struct GNUNET_ATS_AddressListHandle *alh;
+static struct GNUNET_ATS_AddressListHandle *alh;
 
 static struct GNUNET_CONFIGURATION_Handle *cfg;
 
-GNUNET_SCHEDULER_TaskIdentifier end_task;
+static GNUNET_SCHEDULER_TaskIdentifier end_task;
+
 
 struct PendingResolutions
 {
@@ -104,11 +104,15 @@ struct PendingResolutions
   struct GNUNET_TRANSPORT_AddressToStringContext * tats_ctx;
 };
 
-struct PendingResolutions *head;
-struct PendingResolutions *tail;
 
-void end (void *cls,
-          const struct GNUNET_SCHEDULER_TaskContext *tc)
+static struct PendingResolutions *head;
+
+static struct PendingResolutions *tail;
+
+
+static void 
+end (void *cls,
+     const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct PendingResolutions * pr;
   struct PendingResolutions * next;
@@ -145,7 +149,8 @@ void end (void *cls,
 }
 
 
-void transport_addr_to_str_cb (void *cls, const char *address)
+static void 
+transport_addr_to_str_cb (void *cls, const char *address)
 {
   struct PendingResolutions * pr = cls;
   char *ats_str;
@@ -156,11 +161,10 @@ void transport_addr_to_str_cb (void *cls, const char *address)
   uint32_t ats_type;
   uint32_t ats_value;
   uint32_t network;
+
   if (NULL != address)
   {
     ats_str = GNUNET_strdup("");
-
-
     for (c = 0; c < pr->ats_count; c++)
     {
         ats_tmp = ats_str;
@@ -220,17 +224,18 @@ void transport_addr_to_str_cb (void *cls, const char *address)
   }
 }
 
-void ats_perf_cb (void *cls,
-                                                                        const struct GNUNET_HELLO_Address *address,
-                                                                        int active,
-                                                                        struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-                                                                        struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
-                                                                        const struct GNUNET_ATS_Information *ats,
-                                                                        uint32_t ats_count)
+
+static void 
+ats_perf_cb (void *cls,
+             const struct GNUNET_HELLO_Address *address,
+             int active,
+             struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+             struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
+             const struct GNUNET_ATS_Information *ats,
+             uint32_t ats_count)
 {
   struct PendingResolutions * pr;
 
-
   if (NULL != address)
   {
     pr = GNUNET_malloc (sizeof (struct PendingResolutions) +
@@ -325,30 +330,30 @@ print_quotas (const struct GNUNET_CONFIGURATION_Handle *cfg)
 }
 
 
-
-void testservice_ats (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+testservice_ats (void *cls,
+                 int result)
 {
-  struct GNUNET_PeerIdentity pid;
   struct GNUNET_CONFIGURATION_Handle *cfg = cls;
+  struct GNUNET_PeerIdentity pid;
   unsigned int c;
   unsigned int type;
 
-  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
+  if (GNUNET_YES != result)
   {
-      FPRINTF (stderr, _("Service `%s' is not running\n"), "ats");
-      return;
+    FPRINTF (stderr, _("Service `%s' is not running\n"), "ats");
+    return;
   }
 
   results = 0;
 
   if (NULL != pid_str)
   {
-      if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (pid_str, &pid.hashPubKey))
-      {
-        FPRINTF (stderr, _("Failed to parse peer identity `%s'\n"), pid_str);
-        return;
-      }
+    if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (pid_str, &pid.hashPubKey))
+    {
+      FPRINTF (stderr, _("Failed to parse peer identity `%s'\n"), pid_str);
+      return;
+    }
   }
 
   c = op_list_all + op_list_used + op_monitor + op_set_pref;
diff --git a/src/include/gnunet_client_lib.h b/src/include/gnunet_client_lib.h
index 8642dd941..e402b4295 100644
--- a/src/include/gnunet_client_lib.h
+++ b/src/include/gnunet_client_lib.h
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
-     (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009 Christian Grothoff (and other contributing authors)
+     (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2013 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
-     by the Free Software Foundation; either version 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -190,21 +190,49 @@ GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection *client
 
 
 /**
- * Wait until the service is running.
+ * Handle for a test to check if a service is running.
+ */
+struct GNUNET_CLIENT_TestHandle;
+
+/**
+ * Function called with the result on the service test.
+ *
+ * @param cls closure
+ * @param result GNUNET_YES if the service is running,
+ *               GNUNET_NO if the service is not running
+ *               GNUNET_SYSERR if the configuration is invalid
+ */
+typedef void (*GNUNET_CLIENT_TestResultCallback)(void *cls,
+                                                 int result);
+
+
+/**
+ * Test if the service is running.  If we are given a UNIXPATH or a
+ * local address, we do this NOT by trying to connect to the service,
+ * but by trying to BIND to the same port.  If the BIND fails, we know
+ * the service is running.
  *
  * @param service name of the service to wait for
  * @param cfg configuration to use
  * @param timeout how long to wait at most in ms
- * @param task task to run if service is running
- *        (reason will be "PREREQ_DONE" (service running)
- *         or "TIMEOUT" (service not known to be running))
- * @param task_cls closure for task
+ * @param cb function to call with the result
+ * @param cb_cls closure for 'cb'
+ * @return handle to cancel the test
  */
-void
+struct GNUNET_CLIENT_TestHandle *
 GNUNET_CLIENT_service_test (const char *service,
                             const struct GNUNET_CONFIGURATION_Handle *cfg,
                             struct GNUNET_TIME_Relative timeout,
-                            GNUNET_SCHEDULER_Task task, void *task_cls);
+                            GNUNET_CLIENT_TestResultCallback cb, void *cb_cls);
+
+
+/**
+ * Abort testing for service.
+ *
+ * @param th test handle
+ */
+void
+GNUNET_CLIENT_service_test_cancel (struct GNUNET_CLIENT_TestHandle *th);
 
 
 #if 0                           /* keep Emacsens' auto-indent happy */
diff --git a/src/include/gnunet_crypto_lib.h b/src/include/gnunet_crypto_lib.h
index eb16e0120..693cfcf12 100644
--- a/src/include/gnunet_crypto_lib.h
+++ b/src/include/gnunet_crypto_lib.h
@@ -1106,7 +1106,7 @@ GNUNET_CRYPTO_rsa_key_get_public (const struct GNUNET_CRYPTO_RsaPrivateKey
  */
 void
 GNUNET_CRYPTO_rsa_get_public_key_hash (struct GNUNET_CRYPTO_RsaPrivateKey *key,
-    struct GNUNET_HashCode *id);
+                                       struct GNUNET_HashCode *id);
 
 
 /**
diff --git a/src/include/gnunet_service_lib.h b/src/include/gnunet_service_lib.h
index 39e6a8050..cc224ff16 100644
--- a/src/include/gnunet_service_lib.h
+++ b/src/include/gnunet_service_lib.h
@@ -119,8 +119,8 @@ enum GNUNET_SERVICE_Options
  */
 int
 GNUNET_SERVICE_run (int argc, char *const *argv, const char *service_name,
-                    enum GNUNET_SERVICE_Options options, GNUNET_SERVICE_Main task,
-                    void *task_cls);
+                    enum GNUNET_SERVICE_Options options, 
+                    GNUNET_SERVICE_Main task, void *task_cls);
 
 
 /**
diff --git a/src/namestore/gnunet-namestore.c b/src/namestore/gnunet-namestore.c
index 699df0670..20452eb8c 100644
--- a/src/namestore/gnunet-namestore.c
+++ b/src/namestore/gnunet-namestore.c
@@ -326,12 +326,20 @@ display_record (void *cls,
   GNUNET_NAMESTORE_zone_iterator_next (list_it);
 }
 
+
+/**
+ * Function called with the result of the ECC key generation.
+ *
+ * @param cls our configuration
+ * @param pk our private key, NULL on failure
+ * @param emsg NULL on success, otherwise error message
+ */
 static void
 key_generation_cb (void *cls,
                    struct GNUNET_CRYPTO_EccPrivateKey *pk,
                    const char *emsg)
 {
-  struct GNUNET_CONFIGURATION_Handle *cfg = cls;
+  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
   struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pub;
   uint32_t type;
   void *data = NULL;
@@ -599,19 +607,26 @@ key_generation_cb (void *cls,
 }
 
 
+/**
+ * Function called with the result from the check if the namestore
+ * service is actually running.  If it is, we start the actual
+ * operation.
+ *
+ * @param cls closure with our configuration
+ * @param result GNUNET_YES if the namestore service is running
+ */
 static void
 testservice_task (void *cls,
-                  const struct GNUNET_SCHEDULER_TaskContext *tc)
+                  int result)
 {
-  struct GNUNET_CONFIGURATION_Handle *cfg = cls;
+  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
 
-  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
+  if (GNUNET_YES != result)
   {
-      FPRINTF (stderr, _("Service `%s' is not running\n"), "namestore");
-      return;
+    FPRINTF (stderr, _("Service `%s' is not running\n"), 
+             "namestore");
+    return;
   }
-
-
   if (NULL == keyfile)
   {
     if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
@@ -625,7 +640,8 @@ testservice_task (void *cls,
              _("Using default zone file `%s'\n"),
              keyfile);
   }
-  keygen = GNUNET_CRYPTO_ecc_key_create_start (keyfile, key_generation_cb, cfg);
+  keygen = GNUNET_CRYPTO_ecc_key_create_start (keyfile,
+                                               &key_generation_cb, (void *) cfg);
   GNUNET_free (keyfile);
   keyfile = NULL;
   if (NULL == keygen)
@@ -653,9 +669,9 @@ run (void *cls, char *const *args, const char *cfgfile,
     uri = GNUNET_strdup (args[0]);
 
   GNUNET_CLIENT_service_test ("namestore", cfg,
-      GNUNET_TIME_UNIT_SECONDS,
-      &testservice_task,
-      (void *) cfg);
+                              GNUNET_TIME_UNIT_SECONDS,
+                              &testservice_task,
+                              (void *) cfg);
 }
 
 
diff --git a/src/regex/gnunet-regex-simulation-profiler.c b/src/regex/gnunet-regex-simulation-profiler.c
index 32b09eaee..604d25612 100644
--- a/src/regex/gnunet-regex-simulation-profiler.c
+++ b/src/regex/gnunet-regex-simulation-profiler.c
@@ -489,7 +489,7 @@ announce_regex (const char *regex)
  * @return GNUNET_OK to continue to iterate,
  *  GNUNET_SYSERR to abort iteration with error!
  */
-int
+static int
 policy_filename_cb (void *cls, const char *filename)
 {
   char *regex;
diff --git a/src/regex/regex.c b/src/regex/regex.c
index ad8e56b97..711e5458b 100644
--- a/src/regex/regex.c
+++ b/src/regex/regex.c
@@ -3478,6 +3478,7 @@ GNUNET_REGEX_iterate_all_edges (struct GNUNET_REGEX_Automaton *a,
                         NULL, a->start, iterator, iterator_cls);
 }
 
+
 /**
  * Create a string with binary IP notation for the given 'addr' in 'str'.
  *
diff --git a/src/statistics/gnunet-statistics.c b/src/statistics/gnunet-statistics.c
index 2747f7adc..2b2b1c745 100644
--- a/src/statistics/gnunet-statistics.c
+++ b/src/statistics/gnunet-statistics.c
@@ -167,42 +167,18 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 }
 
 
-
+/**
+ * Main task that does the actual work.
+ *
+ * @param cls closure with our configuration
+ * @param tc schedueler context
+ */
 static void
-resolver_test_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+main_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  struct GNUNET_CONFIGURATION_Handle *cfg = cls;
+  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
   struct GNUNET_STATISTICS_Handle *h;
 
-  if (NULL != remote_host)
-  {
-      if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
-      {
-          FPRINTF (stderr, _("Trying to connect to remote host, but service `%s' is not running\n"), "resolver");
-          return;
-      }
-
-      /* connect to a remote host */
-      if (0 == remote_port)
-      {
-        if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg, "statistics", "PORT", &remote_port))
-        {
-          FPRINTF (stderr, _("A port is required to connect to host `%s'\n"), remote_host);
-          return;
-        }
-      }
-      else if (65535 <= remote_port)
-      {
-          FPRINTF (stderr, _("A port has to be between 1 and 65535 to connect to host `%s'\n"), remote_host);
-          return;
-      }
-
-      /* Manipulate configuration */
-      GNUNET_CONFIGURATION_set_value_string ((struct GNUNET_CONFIGURATION_Handle *) cfg, "statistics", "UNIXPATH", "");
-      GNUNET_CONFIGURATION_set_value_string ((struct GNUNET_CONFIGURATION_Handle *) cfg, "statistics", "HOSTNAME", remote_host);
-      GNUNET_CONFIGURATION_set_value_number ((struct GNUNET_CONFIGURATION_Handle *) cfg, "statistics", "PORT", remote_port);
-  }
-
   if (set_value)
   {
     if (subsystem == NULL)
@@ -264,6 +240,52 @@ resolver_test_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 /**
+ * Function called with th test result to see if the resolver is
+ * running.
+ *
+ * @param cls closure with our configuration
+ * @param result GNUNET_YES if the resolver is running
+ */ 
+static void
+resolver_test_task (void *cls, 
+                    int result)
+{
+  struct GNUNET_CONFIGURATION_Handle *cfg = cls;
+
+  if (GNUNET_YES != result)
+   {
+     FPRINTF (stderr, 
+              _("Trying to connect to remote host, but service `%s' is not running\n"), "resolver");
+     return;
+   }
+  /* connect to a remote host */
+  if (0 == remote_port)
+  {
+    if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg, "statistics", "PORT", &remote_port))
+    {
+      FPRINTF (stderr, _("A port is required to connect to host `%s'\n"), remote_host);
+      return;
+    }
+  }
+  else if (65535 <= remote_port)
+  {
+    FPRINTF (stderr, 
+             _("A port has to be between 1 and 65535 to connect to host `%s'\n"), remote_host);
+    return;
+  }
+
+  /* Manipulate configuration */
+  GNUNET_CONFIGURATION_set_value_string (cfg, 
+                                         "statistics", "UNIXPATH", "");
+  GNUNET_CONFIGURATION_set_value_string (cfg,
+                                         "statistics", "HOSTNAME", remote_host);
+  GNUNET_CONFIGURATION_set_value_number (cfg,
+                                         "statistics", "PORT", remote_port);
+  GNUNET_SCHEDULER_add_now (&main_task, cfg);
+}
+
+
+/**
  * Main function that will be run by the scheduler.
  *
  * @param cls closure
@@ -278,20 +300,19 @@ run (void *cls, char *const *args, const char *cfgfile,
   set_value = GNUNET_NO;
   if (NULL != args[0])
   {
-      if (1 != SSCANF (args[0], "%llu", &set_val))
-      {
-          FPRINTF (stderr, _("Invalid argument `%s'\n"), args[0]);
-          ret = 1;
-          return;
-      }
-      set_value = GNUNET_YES;
+    if (1 != SSCANF (args[0], "%llu", &set_val))
+    {
+      FPRINTF (stderr, _("Invalid argument `%s'\n"), args[0]);
+      ret = 1;
+      return;
+    }
+    set_value = GNUNET_YES;
   }
-
   if (NULL != remote_host)
-      GNUNET_CLIENT_service_test ("resolver", cfg, GNUNET_TIME_UNIT_SECONDS, &resolver_test_task, (void *) cfg);
+    GNUNET_CLIENT_service_test ("resolver", cfg, GNUNET_TIME_UNIT_SECONDS, 
+                                &resolver_test_task, (void *) cfg);
   else
-      GNUNET_SCHEDULER_add_now (&resolver_test_task, (void *) cfg);
-
+    GNUNET_SCHEDULER_add_now (&main_task, (void *) cfg);
 }
 
 
diff --git a/src/transport/gnunet-transport.c b/src/transport/gnunet-transport.c
index 1c3b5e59c..c03d6a388 100644
--- a/src/transport/gnunet-transport.c
+++ b/src/transport/gnunet-transport.c
@@ -792,23 +792,32 @@ void try_connect_cb (void *cls,
 }
 
 
+/**
+ * Function called with the result of the check if the 'transport'
+ * service is running.
+ *
+ * @param cls closure with our configuration
+ * @param result GNUNET_YES if transport is running
+ */
 static void
 testservice_task (void *cls,
-                  const struct GNUNET_SCHEDULER_TaskContext *tc)
+                  int result)
 {
   int counter = 0;
   ret = 1;
 
-  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
+  if (GNUNET_YES != result)
   {
-      FPRINTF (stderr, _("Service `%s' is not running\n"), "transport");
-      return;
+    FPRINTF (stderr, 
+             _("Service `%s' is not running\n"), "transport");
+    return;
   }
 
-  if ((NULL != cpid) && (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (cpid, &pid.hashPubKey)))
+  if ( (NULL != cpid) && 
+       (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (cpid, &pid.hashPubKey)))
   {
-      FPRINTF (stderr, _("Failed to parse peer identity `%s'\n"), cpid);
-      return;
+    FPRINTF (stderr, _("Failed to parse peer identity `%s'\n"), cpid);
+    return;
   }
 
   counter = benchmark_send + benchmark_receive + iterate_connections +
@@ -970,11 +979,10 @@ run (void *cls, char *const *args, const char *cfgfile,
     do_test_configuration (cfg);
     return;
   }
-
   GNUNET_CLIENT_service_test ("transport", cfg,
-      GNUNET_TIME_UNIT_SECONDS,
-      &testservice_task,
-      (void *) cfg);
+                              GNUNET_TIME_UNIT_SECONDS,
+                              &testservice_task,
+                              (void *) cfg);
 }
 
 
diff --git a/src/util/client.c b/src/util/client.c
index 8b4776201..73b912cc6 100644
--- a/src/util/client.c
+++ b/src/util/client.c
@@ -179,27 +179,12 @@ struct GNUNET_CLIENT_Connection
   struct GNUNET_CLIENT_TransmitHandle *th;
 
   /**
-   * Handler for service test completion (NULL unless in service_test)
-   */
-  GNUNET_SCHEDULER_Task test_cb;
-
-  /**
-   * Deadline for calling 'test_cb'.
-   */
-  struct GNUNET_TIME_Absolute test_deadline;
-
-  /**
    * If we are re-trying and are delaying to do so,
    * handle to the scheduled task managing the delay.
    */
   GNUNET_SCHEDULER_TaskIdentifier receive_task;
 
   /**
-   * Closure for test_cb (NULL unless in service_test)
-   */
-  void *test_cb_cls;
-
-  /**
    * Buffer for received message.
    */
   char *received_buf;
@@ -639,26 +624,119 @@ GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *client,
 
 
 /**
- * Report service unavailable.
+ * Handle for a test to check if a service is running.
+ */
+struct GNUNET_CLIENT_TestHandle 
+{
+  /**
+   * Function to call with the result of the test.
+   */
+  GNUNET_CLIENT_TestResultCallback cb;
+
+  /**
+   * Closure for 'cb'.
+   */
+  void *cb_cls;
+
+  /**
+   * Client connection we are using for the test, if any.
+   */ 
+  struct GNUNET_CLIENT_Connection *client;
+
+  /**
+   * Handle for the transmission request, if any.
+   */
+  struct GNUNET_CLIENT_TransmitHandle *th;
+
+  /**
+   * Deadline for calling 'cb'.
+   */
+  struct GNUNET_TIME_Absolute test_deadline;
+
+  /**
+   * ID of task used for asynchronous operations.
+   */
+  GNUNET_SCHEDULER_TaskIdentifier task;
+
+  /**
+   * Final result to report back (once known).
+   */
+  int result;
+};
+
+
+/**
+ * Abort testing for service.
+ *
+ * @param th test handle
+ */
+void
+GNUNET_CLIENT_service_test_cancel (struct GNUNET_CLIENT_TestHandle *th)
+{
+  if (NULL != th->th)
+  {
+    GNUNET_CLIENT_notify_transmit_ready_cancel (th->th);
+    th->th = NULL;
+  }
+  if (NULL != th->client)
+  {
+    GNUNET_CLIENT_disconnect (th->client);
+    th->client = NULL;
+  }
+  if (GNUNET_SCHEDULER_NO_TASK != th->task)
+  {
+    GNUNET_SCHEDULER_cancel (th->task);
+    th->task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  GNUNET_free (th);
+}
+
+
+/**
+ * Task that reports back the result by calling the callback
+ * and then cleans up.
+ *
+ * @param cls the 'struct GNUNET_CLIENT_TestHandle'
+ * @param tc scheduler context
+ */
+static void
+report_result (void *cls,
+               const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_CLIENT_TestHandle *th = cls;
+  
+  th->task = GNUNET_SCHEDULER_NO_TASK;
+  th->cb (th->cb_cls, th->result);
+  GNUNET_CLIENT_service_test_cancel (th);
+}
+
+
+/**
+ * Report service test result asynchronously back to callback.
+ *
+ * @param th test handle with the result and the callback
+ * @param result result to report
  */
 static void
-service_test_error (GNUNET_SCHEDULER_Task task, void *task_cls)
+service_test_report (struct GNUNET_CLIENT_TestHandle *th,
+                     int result)
 {
-  GNUNET_SCHEDULER_add_continuation (task, task_cls,
-                                     GNUNET_SCHEDULER_REASON_TIMEOUT);
+  th->result = result;
+  th->task = GNUNET_SCHEDULER_add_now (&report_result,
+                                       th);                                    
 }
 
 
 /**
  * Receive confirmation from test, service is up.
  *
- * @param cls closure
+ * @param cls closure with the 'struct GNUNET_CLIENT_TestHandle'
  * @param msg message received, NULL on timeout or fatal error
  */
 static void
 confirm_handler (void *cls, const struct GNUNET_MessageHeader *msg)
 {
-  struct GNUNET_CLIENT_Connection *client = cls;
+  struct GNUNET_CLIENT_TestHandle *th = cls;
 
   /* We may want to consider looking at the reply in more
    * detail in the future, for example, is this the
@@ -667,14 +745,12 @@ confirm_handler (void *cls, const struct GNUNET_MessageHeader *msg)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Received confirmation that service is running.\n");
-    GNUNET_SCHEDULER_add_continuation (client->test_cb, client->test_cb_cls,
-                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    service_test_report (th, GNUNET_YES);
   }
   else
   {
-    service_test_error (client->test_cb, client->test_cb_cls);
+    service_test_report (th, GNUNET_NO);
   }
-  GNUNET_CLIENT_disconnect (client);
 }
 
 
@@ -682,7 +758,7 @@ confirm_handler (void *cls, const struct GNUNET_MessageHeader *msg)
  * Send the 'TEST' message to the service.  If successful, prepare to
  * receive the reply.
  *
- * @param cls the 'struct GNUNET_CLIENT_Connection' of the connection to test
+ * @param cls the 'struct GNUNET_CLIENT_TestHandle' of the test
  * @param size number of bytes available in buf
  * @param buf where to write the message
  * @return number of bytes written to buf
@@ -690,52 +766,61 @@ confirm_handler (void *cls, const struct GNUNET_MessageHeader *msg)
 static size_t
 write_test (void *cls, size_t size, void *buf)
 {
-  struct GNUNET_CLIENT_Connection *client = cls;
+  struct GNUNET_CLIENT_TestHandle *th = cls;
   struct GNUNET_MessageHeader *msg;
 
+  th->th = NULL;
   if (size < sizeof (struct GNUNET_MessageHeader))
   {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, _("Failure to transmit TEST request.\n"));
-    service_test_error (client->test_cb, client->test_cb_cls);
-    GNUNET_CLIENT_disconnect (client);
+    LOG (GNUNET_ERROR_TYPE_DEBUG, 
+         "Failed to transmit TEST request.\n");
+    service_test_report (th, GNUNET_NO);
     return 0;                   /* client disconnected */
   }
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Transmitting `%s' request.\n", "TEST");
+  LOG (GNUNET_ERROR_TYPE_DEBUG, 
+       "Transmitting `%s' request.\n", 
+       "TEST");
   msg = (struct GNUNET_MessageHeader *) buf;
   msg->type = htons (GNUNET_MESSAGE_TYPE_TEST);
   msg->size = htons (sizeof (struct GNUNET_MessageHeader));
-  GNUNET_CLIENT_receive (client, &confirm_handler, client,
+  GNUNET_CLIENT_receive (th->client, 
+                         &confirm_handler, th,
                          GNUNET_TIME_absolute_get_remaining
-                         (client->test_deadline));
+                         (th->test_deadline));
   return sizeof (struct GNUNET_MessageHeader);
 }
 
 
 /**
- * Test if the service is running.  If we are given a UNIXPATH or a local address,
- * we do this NOT by trying to connect to the service, but by trying to BIND to
- * the same port.  If the BIND fails, we know the service is running.
+ * Test if the service is running.  If we are given a UNIXPATH or a
+ * local address, we do this NOT by trying to connect to the service,
+ * but by trying to BIND to the same port.  If the BIND fails, we know
+ * the service is running.
  *
  * @param service name of the service to wait for
  * @param cfg configuration to use
  * @param timeout how long to wait at most
- * @param task task to run if service is running
- *        (reason will be "PREREQ_DONE" (service running)
- *         or "TIMEOUT" (service not known to be running))
- * @param task_cls closure for task
+ * @param cb function to call with the result
+ * @param cb_cls closure for 'cb'
+ * @return handle to cancel the test
  */
-void
+struct GNUNET_CLIENT_TestHandle *
 GNUNET_CLIENT_service_test (const char *service,
                             const struct GNUNET_CONFIGURATION_Handle *cfg,
                             struct GNUNET_TIME_Relative timeout,
-                            GNUNET_SCHEDULER_Task task, void *task_cls)
+                            GNUNET_CLIENT_TestResultCallback cb, void *cb_cls)
 {
+  struct GNUNET_CLIENT_TestHandle *th;
   char *hostname;
   unsigned long long port;
   struct GNUNET_NETWORK_Handle *sock;
-  struct GNUNET_CLIENT_Connection *client;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Testing if service `%s' is running.\n",
+  th = GNUNET_new (struct GNUNET_CLIENT_TestHandle);
+  th->cb = cb;
+  th->cb_cls = cb_cls;
+  th->test_deadline = GNUNET_TIME_relative_to_absolute (timeout);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, 
+       "Testing if service `%s' is running.\n",
        service);
 #ifdef AF_UNIX
   {
@@ -783,9 +868,8 @@ GNUNET_CLIENT_service_test (const char *service,
           /* failed to bind => service must be running */
           GNUNET_free (unixpath);
           (void) GNUNET_NETWORK_socket_close (sock);
-          GNUNET_SCHEDULER_add_continuation (task, task_cls,
-                                             GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-          return;
+          service_test_report (th, GNUNET_YES);
+          return th;
         }
         (void) GNUNET_NETWORK_socket_close (sock);        
         /* let's try IP */
@@ -804,8 +888,8 @@ GNUNET_CLIENT_service_test (const char *service,
                                               &hostname)))
   {
     /* UNIXPATH failed (if possible) AND IP failed => error */
-    service_test_error (task, task_cls);
-    return;
+    service_test_report (th, GNUNET_SYSERR);
+    return th;
   }
 
   if (0 == strcmp ("localhost", hostname)
@@ -834,9 +918,8 @@ GNUNET_CLIENT_service_test (const char *service,
         /* failed to bind => service must be running */
         GNUNET_free (hostname);
         (void) GNUNET_NETWORK_socket_close (sock);
-        GNUNET_SCHEDULER_add_continuation (task, task_cls,
-                                           GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-        return;
+        service_test_report (th, GNUNET_YES);
+        return th;
       }
       (void) GNUNET_NETWORK_socket_close (sock);
     }
@@ -868,9 +951,8 @@ GNUNET_CLIENT_service_test (const char *service,
         /* failed to bind => service must be running */
         GNUNET_free (hostname);
         (void) GNUNET_NETWORK_socket_close (sock);
-        GNUNET_SCHEDULER_add_continuation (task, task_cls,
-                                           GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-        return;
+        service_test_report (th, GNUNET_YES);
+        return th;
       }
       (void) GNUNET_NETWORK_socket_close (sock);
     }
@@ -885,35 +967,33 @@ GNUNET_CLIENT_service_test (const char *service,
   {
     /* all binds succeeded => claim service not running right now */
     GNUNET_free_non_null (hostname);
-    service_test_error (task, task_cls);
-    return;
+    service_test_report (th, GNUNET_NO);
+    return th;
   }
   GNUNET_free_non_null (hostname);
 
   /* non-localhost, try 'connect' method */
-  client = GNUNET_CLIENT_connect (service, cfg);
-  if (NULL == client)
+  th->client = GNUNET_CLIENT_connect (service, cfg);
+  if (NULL == th->client)
   {
     LOG (GNUNET_ERROR_TYPE_INFO,
-         _("Could not connect to service `%s', must not be running.\n"),
+         _("Could not connect to service `%s', configuration broken.\n"),
          service);
-    service_test_error (task, task_cls);
-    return;
+    service_test_report (th, GNUNET_SYSERR);
+    return th;
   }
-  client->test_cb = task;
-  client->test_cb_cls = task_cls;
-  client->test_deadline = GNUNET_TIME_relative_to_absolute (timeout);
-  if (NULL == GNUNET_CLIENT_notify_transmit_ready (client,
-                                                   sizeof (struct GNUNET_MessageHeader),
-                                                   timeout, GNUNET_YES, &write_test,
-                                                   client))
+  th->th = GNUNET_CLIENT_notify_transmit_ready (th->client,
+                                                sizeof (struct GNUNET_MessageHeader),
+                                                timeout, GNUNET_YES,
+                                                &write_test, th);
+  if (NULL == th->th)
   {
     LOG (GNUNET_ERROR_TYPE_WARNING,
          _("Failure to transmit request to service `%s'\n"), service);
-    service_test_error (task, task_cls);
-    GNUNET_CLIENT_disconnect (client);
-    return;
+    service_test_report (th, GNUNET_SYSERR);
+    return th;
   }
+  return th;
 }
 
 
@@ -1246,5 +1326,4 @@ GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection *client
 }
 
 
-
 /*  end of client.c */
diff --git a/src/util/test_service.c b/src/util/test_service.c
index be49d1877..bdd3d8521 100644
--- a/src/util/test_service.c
+++ b/src/util/test_service.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2009 Christian Grothoff (and other contributing authors)
+     (C) 2009, 2013 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
@@ -20,6 +20,7 @@
 /**
  * @file util/test_service.c
  * @brief tests for service.c
+ * @author Christian Grothoff
  */
 #include "platform.h"
 #include "gnunet_common.h"
@@ -33,6 +34,9 @@
 
 #define PORT 12435
 
+/**
+ * Message type we use for testing.
+ */
 #define MY_TYPE 256
 
 static struct GNUNET_SERVICE_Context *sctx;
@@ -42,8 +46,6 @@ static int ok = 1;
 static struct GNUNET_CLIENT_Connection *client;
 
 
-
-
 static void
 do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
@@ -87,11 +89,12 @@ build_msg (void *cls, size_t size, void *buf)
 
 
 static void
-ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+ready (void *cls,
+       int result)
 {
   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
 
-  GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
+  GNUNET_assert (GNUNET_YES == result);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service confirmed running\n");
   client = GNUNET_CLIENT_connect ("test_service", cfg);
   GNUNET_assert (client != NULL);
@@ -108,8 +111,7 @@ static void
 recv_cb (void *cls, struct GNUNET_SERVER_Client *sc,
          const struct GNUNET_MessageHeader *message)
 {
-  if (NULL == message)
-    return;
+  GNUNET_assert (NULL != message);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving client message...\n");
   GNUNET_SERVER_receive_done (sc, GNUNET_OK);
   GNUNET_SCHEDULER_add_now (&do_stop, NULL);
@@ -156,13 +158,15 @@ check ()
   return ok;
 }
 
+
 static void
-ready6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+ready6 (void *cls, 
+        int result)
 {
   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "V6 ready\n");
-  GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
+  GNUNET_assert (GNUNET_YES == result);
   client = GNUNET_CLIENT_connect ("test_service6", cfg);
   GNUNET_assert (client != NULL);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "V6 client connected\n");
@@ -172,6 +176,7 @@ ready6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                        &build_msg, NULL);
 }
 
+
 static void
 runner6 (void *cls, struct GNUNET_SERVER_Handle *server,
          const struct GNUNET_CONFIGURATION_Handle *cfg)
@@ -182,6 +187,7 @@ runner6 (void *cls, struct GNUNET_SERVER_Handle *server,
                               &ready6, (void *) cfg);
 }
 
+
 /**
  * Main method, starts scheduler with task1,
  * checks that "ok" is correct at the end.
@@ -205,7 +211,6 @@ check6 ()
 }
 
 
-
 static void
 start_stop_main (void *cls, char *const *args, const char *cfgfile,
                  const struct GNUNET_CONFIGURATION_Handle *cfg)