moving code where it belongs:

1 files changed, 205 insertions, 1 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 */