moving code where it belongs:

5 files changed, 418 insertions, 242 deletions

diff --git a/src/arm/arm_api.c b/src/arm/arm_api.c
index ee53fd87b..f15c9ab53 100644
--- a/src/arm/arm_api.c
+++ b/src/arm/arm_api.c
@@ -65,6 +65,206 @@ struct GNUNET_ARM_Handle
 
 
 /**
+ * Context for handling the shutdown of a service.
+ */
+struct ShutdownContext
+{
+  /**
+   * Scheduler to be used to call continuation
+   */
+  struct GNUNET_SCHEDULER_Handle *sched;
+  /**
+   * Connection to the service that is being shutdown.
+   */
+  struct GNUNET_CLIENT_Connection *sock;
+
+  /**
+   * Time allowed for shutdown to happen.
+   */
+  struct GNUNET_TIME_Absolute timeout;
+
+  /**
+   * Task set up to cancel the shutdown request on timeout.
+   */
+  GNUNET_SCHEDULER_TaskIdentifier cancel_task;
+
+  /**
+   * Task to call once shutdown complete
+   */
+  GNUNET_CLIENT_ShutdownTask cont;
+
+  /**
+   * Closure for shutdown continuation
+   */
+  void *cont_cls;
+
+  /**
+   * We received a confirmation that the service will shut down.
+   */
+  int confirmed;
+
+};
+
+/**
+ * Handler receiving response to service shutdown requests.
+ * First call with NULL: service misbehaving, or something.
+ * First call with GNUNET_MESSAGE_TYPE_ARM_SHUTDOWN_ACK:
+ *   - service will shutdown
+ * Second call with NULL:
+ *   - service has now really shut down.
+ *
+ * @param cls closure
+ * @param msg NULL, indicating socket closure.
+ */
+static void
+service_shutdown_handler (void *cls, const struct GNUNET_MessageHeader *msg)
+{
+  struct ShutdownContext *shutdown_ctx = cls;
+
+  if ((msg == NULL) && (shutdown_ctx->confirmed != GNUNET_YES))   
+    {
+      /* Means the other side closed the connection and never confirmed a shutdown */
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, 
+                  "Service handle shutdown before ACK!\n");
+      if (shutdown_ctx->cont != NULL)
+        shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR);      
+      GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, 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))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, 
+                 "Service shutdown complete.\n");
+      if (shutdown_ctx->cont != NULL)
+        shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_NO);
+
+      GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task);
+      GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
+      GNUNET_free(shutdown_ctx);
+    }
+  else
+    {
+      GNUNET_assert(ntohs(msg->size) == sizeof(struct GNUNET_MessageHeader));
+      switch (ntohs(msg->type))
+        {
+        case GNUNET_MESSAGE_TYPE_ARM_SHUTDOWN_ACK:
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                     "Received confirmation for service shutdown.\n");
+          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 */
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING, 
+                     "Service shutdown refused!\n");
+          if (shutdown_ctx->cont != NULL)
+            shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_YES);
+          
+          GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task);
+          GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
+          GNUNET_free(shutdown_ctx);
+          break;
+        }
+    }
+}
+
+/**
+ * Shutting down took too long, cancel receive and return error.
+ *
+ * @param cls closure
+ * @param tc context information (why was this task triggered now)
+ */
+void service_shutdown_cancel (void *cls,
+                              const struct GNUNET_SCHEDULER_TaskContext * tc)
+{
+  struct ShutdownContext *shutdown_ctx = cls;
+  GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "service_shutdown_cancel called!\n");
+  shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR);
+  GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
+  GNUNET_free(shutdown_ctx);
+}
+
+
+/**
+ * If possible, write a shutdown message to the target
+ * buffer and destroy the client connection.
+ *
+ * @param cls the "struct GNUNET_CLIENT_Connection" to destroy
+ * @param size number of bytes available in buf
+ * @param buf NULL on error, otherwise target buffer
+ * @return number of bytes written to buf
+ */
+static size_t
+write_shutdown (void *cls, size_t size, void *buf)
+{
+  struct GNUNET_MessageHeader *msg;
+  struct ShutdownContext *shutdown_ctx = cls;
+
+  if (size < sizeof (struct GNUNET_MessageHeader))
+    {
+      GNUNET_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);
+      GNUNET_free(shutdown_ctx);
+      return 0;                 /* client disconnected */
+    }
+
+  GNUNET_CLIENT_receive (shutdown_ctx->sock,
+                         &service_shutdown_handler, shutdown_ctx, 
+                         GNUNET_TIME_UNIT_FOREVER_REL);
+  shutdown_ctx->cancel_task = GNUNET_SCHEDULER_add_delayed (shutdown_ctx->sched, 
+                                                            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));
+  return sizeof (struct GNUNET_MessageHeader);
+}
+
+
+/**
+ * Request that the service should shutdown.
+ * Afterwards, the connection will automatically be
+ * disconnected.  Hence the "sock" should not
+ * be used by the caller after this call
+ * (calling this function frees "sock" after a while).
+ *
+ * @param sched the scheduler to use for calling shutdown continuation
+ * @param sock the socket connected to the service
+ * @param timeout how long to wait before giving up on transmission
+ * @param cont continuation to call once the service is really down
+ * @param cont_cls closure for continuation
+ *
+ */
+static void
+arm_service_shutdown (struct GNUNET_SCHEDULER_Handle *sched,
+                      struct GNUNET_CLIENT_Connection *sock,
+                      struct GNUNET_TIME_Relative timeout,
+                      GNUNET_CLIENT_ShutdownTask cont,
+                      void *cont_cls)
+{
+  struct ShutdownContext *shutdown_ctx;
+  shutdown_ctx = GNUNET_malloc(sizeof(struct ShutdownContext));
+  shutdown_ctx->sched = sched;
+  shutdown_ctx->cont = cont;
+  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_NO,
+                                       &write_shutdown, shutdown_ctx);
+}
+
+
+/**
  * Setup a context for communicating with ARM.  Note that this
  * can be done even if the ARM service is not yet running.
  *
@@ -498,7 +698,7 @@ GNUNET_ARM_stop_service (struct GNUNET_ARM_Handle *h,
       arm_shutdown_ctx = GNUNET_malloc(sizeof(struct ARM_ShutdownContext));
       arm_shutdown_ctx->cb = cb;
       arm_shutdown_ctx->cb_cls = cb_cls;
-      GNUNET_CLIENT_service_shutdown (h->sched, h->client, timeout, &arm_shutdown_callback, arm_shutdown_ctx);
+      arm_service_shutdown (h->sched, h->client, timeout, &arm_shutdown_callback, arm_shutdown_ctx);
       h->client = NULL;
       return;
     }
@@ -669,4 +869,8 @@ GNUNET_ARM_stop_services (const struct GNUNET_CONFIGURATION_Handle *cfg,
 }
 
 
+
+
+
+
 /* end of arm_api.c */
diff --git a/src/arm/test_exponential_backoff.c b/src/arm/test_exponential_backoff.c
index 8657563fc..0ff0ebdad 100644
--- a/src/arm/test_exponential_backoff.c
+++ b/src/arm/test_exponential_backoff.c
@@ -26,6 +26,7 @@
 #include "gnunet_client_lib.h"
 #include "gnunet_configuration_lib.h"
 #include "gnunet_program_lib.h"
+#include "gnunet_protocols.h"
 
 #define VERBOSE GNUNET_NO
 #define START_ARM GNUNET_YES
@@ -49,6 +50,206 @@ static char *killLogFileName;
 #endif
 
 
+/**
+ * Context for handling the shutdown of a service.
+ */
+struct ShutdownContext
+{
+  /**
+   * Scheduler to be used to call continuation
+   */
+  struct GNUNET_SCHEDULER_Handle *sched;
+  /**
+   * Connection to the service that is being shutdown.
+   */
+  struct GNUNET_CLIENT_Connection *sock;
+
+  /**
+   * Time allowed for shutdown to happen.
+   */
+  struct GNUNET_TIME_Absolute timeout;
+
+  /**
+   * Task set up to cancel the shutdown request on timeout.
+   */
+  GNUNET_SCHEDULER_TaskIdentifier cancel_task;
+
+  /**
+   * Task to call once shutdown complete
+   */
+  GNUNET_CLIENT_ShutdownTask cont;
+
+  /**
+   * Closure for shutdown continuation
+   */
+  void *cont_cls;
+
+  /**
+   * We received a confirmation that the service will shut down.
+   */
+  int confirmed;
+
+};
+
+/**
+ * Handler receiving response to service shutdown requests.
+ * First call with NULL: service misbehaving, or something.
+ * First call with GNUNET_MESSAGE_TYPE_ARM_SHUTDOWN_ACK:
+ *   - service will shutdown
+ * Second call with NULL:
+ *   - service has now really shut down.
+ *
+ * @param cls closure
+ * @param msg NULL, indicating socket closure.
+ */
+static void
+service_shutdown_handler (void *cls, const struct GNUNET_MessageHeader *msg)
+{
+  struct ShutdownContext *shutdown_ctx = cls;
+
+  if ((msg == NULL) && (shutdown_ctx->confirmed != GNUNET_YES))   
+    {
+      /* Means the other side closed the connection and never confirmed a shutdown */
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, 
+                  "Service handle shutdown before ACK!\n");
+      if (shutdown_ctx->cont != NULL)
+        shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR);      
+      GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, 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))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, 
+                 "Service shutdown complete.\n");
+      if (shutdown_ctx->cont != NULL)
+        shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_NO);
+
+      GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task);
+      GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
+      GNUNET_free(shutdown_ctx);
+    }
+  else
+    {
+      GNUNET_assert(ntohs(msg->size) == sizeof(struct GNUNET_MessageHeader));
+      switch (ntohs(msg->type))
+        {
+        case GNUNET_MESSAGE_TYPE_ARM_SHUTDOWN_ACK:
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+                     "Received confirmation for service shutdown.\n");
+          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 */
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING, 
+                     "Service shutdown refused!\n");
+          if (shutdown_ctx->cont != NULL)
+            shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_YES);
+          
+          GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task);
+          GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
+          GNUNET_free(shutdown_ctx);
+          break;
+        }
+    }
+}
+
+/**
+ * Shutting down took too long, cancel receive and return error.
+ *
+ * @param cls closure
+ * @param tc context information (why was this task triggered now)
+ */
+void service_shutdown_cancel (void *cls,
+                              const struct GNUNET_SCHEDULER_TaskContext * tc)
+{
+  struct ShutdownContext *shutdown_ctx = cls;
+  GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "service_shutdown_cancel called!\n");
+  shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR);
+  GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
+  GNUNET_free(shutdown_ctx);
+}
+
+
+/**
+ * If possible, write a shutdown message to the target
+ * buffer and destroy the client connection.
+ *
+ * @param cls the "struct GNUNET_CLIENT_Connection" to destroy
+ * @param size number of bytes available in buf
+ * @param buf NULL on error, otherwise target buffer
+ * @return number of bytes written to buf
+ */
+static size_t
+write_shutdown (void *cls, size_t size, void *buf)
+{
+  struct GNUNET_MessageHeader *msg;
+  struct ShutdownContext *shutdown_ctx = cls;
+
+  if (size < sizeof (struct GNUNET_MessageHeader))
+    {
+      GNUNET_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);
+      GNUNET_free(shutdown_ctx);
+      return 0;                 /* client disconnected */
+    }
+
+  GNUNET_CLIENT_receive (shutdown_ctx->sock,
+                         &service_shutdown_handler, shutdown_ctx, 
+                         GNUNET_TIME_UNIT_FOREVER_REL);
+  shutdown_ctx->cancel_task = GNUNET_SCHEDULER_add_delayed (shutdown_ctx->sched, 
+                                                            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));
+  return sizeof (struct GNUNET_MessageHeader);
+}
+
+
+/**
+ * Request that the service should shutdown.
+ * Afterwards, the connection will automatically be
+ * disconnected.  Hence the "sock" should not
+ * be used by the caller after this call
+ * (calling this function frees "sock" after a while).
+ *
+ * @param sched the scheduler to use for calling shutdown continuation
+ * @param sock the socket connected to the service
+ * @param timeout how long to wait before giving up on transmission
+ * @param cont continuation to call once the service is really down
+ * @param cont_cls closure for continuation
+ *
+ */
+static void
+arm_service_shutdown (struct GNUNET_SCHEDULER_Handle *sched,
+                      struct GNUNET_CLIENT_Connection *sock,
+                      struct GNUNET_TIME_Relative timeout,
+                      GNUNET_CLIENT_ShutdownTask cont,
+                      void *cont_cls)
+{
+  struct ShutdownContext *shutdown_ctx;
+  shutdown_ctx = GNUNET_malloc(sizeof(struct ShutdownContext));
+  shutdown_ctx->sched = sched;
+  shutdown_ctx->cont = cont;
+  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_NO,
+                                       &write_shutdown, shutdown_ctx);
+}
+
+
 static void
 arm_notify_stop (void *cls, int success)
 {
@@ -141,6 +342,8 @@ shutdown_cont (void *cls, int reason)
                                 &do_test,
                                 NULL);
 }
+
+
 static void
 kill_task (void *cbData,
                    const struct GNUNET_SCHEDULER_TaskContext *tc)
@@ -178,10 +381,10 @@ kill_task (void *cbData,
   }
   
   /* Use the created connection to kill the doNothingTask */
-  GNUNET_CLIENT_service_shutdown(sched,
-                                 doNothingConnection, 
-                                 TIMEOUT, 
-                                 &shutdown_cont, NULL);
+  arm_service_shutdown(sched,
+                       doNothingConnection, 
+                       TIMEOUT, 
+                       &shutdown_cont, NULL);
 }
 
        
diff --git a/src/include/gnunet_client_lib.h b/src/include/gnunet_client_lib.h
index 56f6915a4..49ccc6c6b 100644
--- a/src/include/gnunet_client_lib.h
+++ b/src/include/gnunet_client_lib.h
@@ -207,29 +207,6 @@ GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection *sock,
                                          void *rn_cls);
 
 
-
-/**
- * Request that the service should shutdown.
- * Afterwards, the connection will automatically be
- * disconnected.  Hence the "sock" shoud not
- * be used by the caller after this call
- * (calling this function frees "sock" after a while).
- *
- * @param sched the scheduler to use for calling shutdown continuation
- * @param sock the socket connected to the service
- * @param timeout how long to wait before giving up on transmission
- * @param cont continuation to call once the service is really down
- * @param cont_cls closure for continuation
- *
- */
-void
-GNUNET_CLIENT_service_shutdown (struct GNUNET_SCHEDULER_Handle *sched,
-                                struct GNUNET_CLIENT_Connection *sock,
-                                struct GNUNET_TIME_Relative timeout,
-                                GNUNET_CLIENT_ShutdownTask cont,
-                                void *cont_cls);
-
-
 /**
  * Wait until the service is running.
  *
diff --git a/src/util/client.c b/src/util/client.c
index c87d239e6..8a93bae9b 100644
--- a/src/util/client.c
+++ b/src/util/client.c
@@ -137,47 +137,6 @@ struct TransmitGetResponseContext
 };
 
 /**
- * Context for handling the shutdown of a service.
- */
-struct ShutdownContext
-{
-  /**
-   * Scheduler to be used to call continuation
-   */
-  struct GNUNET_SCHEDULER_Handle *sched;
-  /**
-   * Connection to the service that is being shutdown.
-   */
-  struct GNUNET_CLIENT_Connection *sock;
-
-  /**
-   * Time allowed for shutdown to happen.
-   */
-  struct GNUNET_TIME_Absolute timeout;
-
-  /**
-   * Task set up to cancel the shutdown request on timeout.
-   */
-  GNUNET_SCHEDULER_TaskIdentifier cancel_task;
-
-  /**
-   * Task to call once shutdown complete
-   */
-  GNUNET_CLIENT_ShutdownTask cont;
-
-  /**
-   * Closure for shutdown continuation
-   */
-  void *cont_cls;
-
-  /**
-   * We received a confirmation that the service will shut down.
-   */
-  int confirmed;
-
-};
-
-/**
  * Struct to refer to a GNUnet TCP connection.
  * This is more than just a socket because if the server
  * drops the connection, the client automatically tries
@@ -581,167 +540,6 @@ GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock,
 
 
 /**
- * Handler receiving response to service shutdown requests.
- * First call with NULL: service misbehaving, or something.
- * First call with GNUNET_MESSAGE_TYPE_SHUTDOWN_ACK:
- *   - service will shutdown
- * First call with GNUNET_MESSAGE_TYPE_SHUTDOWN_REFUSE:
- *   - service will not be stopped!
- *
- * Second call with NULL:
- *   - service has now really shut down.
- *
- * @param cls closure
- * @param msg NULL, indicating socket closure.
- */
-static void
-service_shutdown_handler (void *cls, const struct GNUNET_MessageHeader *msg)
-{
-  struct ShutdownContext *shutdown_ctx = cls;
-
-  if ((msg == NULL) && (shutdown_ctx->confirmed != GNUNET_YES))   
-    {
-      /* Means the other side closed the connection and never confirmed a shutdown */
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, 
-                  "Service handle shutdown before ACK!\n");
-      if (shutdown_ctx->cont != NULL)
-        shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR);      
-      GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, 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))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, 
-                 "Service shutdown complete.\n");
-      if (shutdown_ctx->cont != NULL)
-        shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_NO);
-
-      GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task);
-      GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
-      GNUNET_free(shutdown_ctx);
-    }
-  else
-    {
-      GNUNET_assert(ntohs(msg->size) == sizeof(struct GNUNET_MessageHeader));
-      switch (ntohs(msg->type))
-        {
-        case GNUNET_MESSAGE_TYPE_SHUTDOWN_ACK:
-          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                     "Received confirmation for service shutdown.\n");
-          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 */
-          GNUNET_log(GNUNET_ERROR_TYPE_WARNING, 
-                     "Service shutdown refused!\n");
-          if (shutdown_ctx->cont != NULL)
-            shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_YES);
-          
-          GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task);
-          GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
-          GNUNET_free(shutdown_ctx);
-          break;
-        }
-    }
-}
-
-/**
- * Shutting down took too long, cancel receive and return error.
- *
- * @param cls closure
- * @param tc context information (why was this task triggered now)
- */
-void service_shutdown_cancel (void *cls,
-                              const struct GNUNET_SCHEDULER_TaskContext * tc)
-{
-  struct ShutdownContext *shutdown_ctx = cls;
-  GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "service_shutdown_cancel called!\n");
-  shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR);
-  GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO);
-  GNUNET_free(shutdown_ctx);
-}
-
-
-/**
- * If possible, write a shutdown message to the target
- * buffer and destroy the client connection.
- *
- * @param cls the "struct GNUNET_CLIENT_Connection" to destroy
- * @param size number of bytes available in buf
- * @param buf NULL on error, otherwise target buffer
- * @return number of bytes written to buf
- */
-static size_t
-write_shutdown (void *cls, size_t size, void *buf)
-{
-  struct GNUNET_MessageHeader *msg;
-  struct ShutdownContext *shutdown_ctx = cls;
-
-  if (size < sizeof (struct GNUNET_MessageHeader))
-    {
-      GNUNET_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);
-      GNUNET_free(shutdown_ctx);
-      return 0;                 /* client disconnected */
-    }
-
-  GNUNET_CLIENT_receive (shutdown_ctx->sock,
-                         &service_shutdown_handler, shutdown_ctx, 
-                         GNUNET_TIME_UNIT_FOREVER_REL);
-  shutdown_ctx->cancel_task = GNUNET_SCHEDULER_add_delayed (shutdown_ctx->sched, 
-                                                            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));
-  return sizeof (struct GNUNET_MessageHeader);
-}
-
-
-/**
- * Request that the service should shutdown.
- * Afterwards, the connection will automatically be
- * disconnected.  Hence the "sock" should not
- * be used by the caller after this call
- * (calling this function frees "sock" after a while).
- *
- * @param sched the scheduler to use for calling shutdown continuation
- * @param sock the socket connected to the service
- * @param timeout how long to wait before giving up on transmission
- * @param cont continuation to call once the service is really down
- * @param cont_cls closure for continuation
- *
- */
-void
-GNUNET_CLIENT_service_shutdown (struct GNUNET_SCHEDULER_Handle *sched,
-                                struct GNUNET_CLIENT_Connection *sock,
-                                struct GNUNET_TIME_Relative timeout,
-                                GNUNET_CLIENT_ShutdownTask cont,
-                                void *cont_cls)
-{
-  struct ShutdownContext *shutdown_ctx;
-  shutdown_ctx = GNUNET_malloc(sizeof(struct ShutdownContext));
-  shutdown_ctx->sched = sched;
-  shutdown_ctx->cont = cont;
-  shutdown_ctx->cont_cls = cont_cls;
-  shutdown_ctx->sock = sock;
-  shutdown_ctx->timeout = GNUNET_TIME_relative_to_absolute(timeout);
-  GNUNET_CONNECTION_notify_transmit_ready (sock->sock,
-                                           sizeof (struct
-                                                   GNUNET_MessageHeader),
-                                           timeout,
-                                           &write_shutdown, shutdown_ctx);
-}
-
-
-/**
  * Report service unavailable.
  */
 static void
diff --git a/src/util/test_service.c b/src/util/test_service.c
index 544f86fba..5f3146205 100644
--- a/src/util/test_service.c
+++ b/src/util/test_service.c
@@ -43,24 +43,18 @@ static struct GNUNET_SERVICE_Context *sctx;
 
 static int ok = 1;
 
-void
-end_cont (void *cls,
-          int reason)
-{
-  if (sctx != NULL)
-    GNUNET_SERVICE_stop (sctx);
-  else
-    GNUNET_SCHEDULER_shutdown (sched);
-  ok = 0;
-}
-
 static void
 end_it (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_CLIENT_Connection *client = cls;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down service\n");
-  GNUNET_CLIENT_service_shutdown (sched, client, GNUNET_TIME_UNIT_FOREVER_REL, &end_cont, NULL);
+  GNUNET_CLIENT_disconnect (client, GNUNET_NO);
+  if (sctx != NULL)
+    {
+      GNUNET_SERVICE_stop (sctx);
+      sctx = NULL;
+    }
 }