moving code where it belongs:

1 files changed, 207 insertions, 4 deletions

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);
 }