[GNUnet-SVN] r11310 - in gnunet/src: arm include util

[gnunet]

Author: grothoff
Date: 2010-05-11 15:16:00 +0200 (Tue, 11 May 2010)
New Revision: 11310

Modified:
   gnunet/src/arm/arm_api.c
   gnunet/src/arm/test_exponential_backoff.c
   gnunet/src/include/gnunet_client_lib.h
   gnunet/src/util/client.c
   gnunet/src/util/test_service.c
Log:
moving code where it belongs:

Modified: gnunet/src/arm/arm_api.c
===================================================================
--- gnunet/src/arm/arm_api.c    2010-05-11 13:08:27 UTC (rev 11309)
+++ gnunet/src/arm/arm_api.c    2010-05-11 13:16:00 UTC (rev 11310)
@@ -65,6 +65,206 @@
 
 
 /**
+ * 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 @@
       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 @@
 }
 
 
+
+
+
+
 /* end of arm_api.c */

Modified: gnunet/src/arm/test_exponential_backoff.c
===================================================================
--- gnunet/src/arm/test_exponential_backoff.c   2010-05-11 13:08:27 UTC (rev 
11309)
+++ gnunet/src/arm/test_exponential_backoff.c   2010-05-11 13:16:00 UTC (rev 
11310)
@@ -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,7 +50,207 @@
 #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)
 {
   GNUNET_assert (success == GNUNET_NO);
@@ -141,6 +342,8 @@
                                 &do_test,
                                 NULL);
 }
+
+
 static void
 kill_task (void *cbData,
                   const struct GNUNET_SCHEDULER_TaskContext *tc)
@@ -178,10 +381,10 @@
   }
   
   /* 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);
 }
 
        

Modified: gnunet/src/include/gnunet_client_lib.h
===================================================================
--- gnunet/src/include/gnunet_client_lib.h      2010-05-11 13:08:27 UTC (rev 
11309)
+++ gnunet/src/include/gnunet_client_lib.h      2010-05-11 13:16:00 UTC (rev 
11310)
@@ -207,30 +207,7 @@
                                         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.
  *
  * @param sched scheduler to use

Modified: gnunet/src/util/client.c
===================================================================
--- gnunet/src/util/client.c    2010-05-11 13:08:27 UTC (rev 11309)
+++ gnunet/src/util/client.c    2010-05-11 13:16:00 UTC (rev 11310)
@@ -137,47 +137,6 @@
 };
 
 /**
- * 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 @@
 
 
 /**
- * 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

Modified: gnunet/src/util/test_service.c
===================================================================
--- gnunet/src/util/test_service.c      2010-05-11 13:08:27 UTC (rev 11309)
+++ gnunet/src/util/test_service.c      2010-05-11 13:16:00 UTC (rev 11310)
@@ -43,24 +43,18 @@
 
 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;
+    }
 }