migrating testbed to new service API

1 files changed, 290 insertions, 313 deletions

diff --git a/src/testbed/gnunet-service-testbed_barriers.c b/src/testbed/gnunet-service-testbed_barriers.c
index c3ae82ed8..831bc3c6d 100644
--- a/src/testbed/gnunet-service-testbed_barriers.c
+++ b/src/testbed/gnunet-service-testbed_barriers.c
@@ -61,28 +61,6 @@ struct Barrier;
 
 
 /**
- * Message queue for transmitting messages
- */
-struct MessageQueue
-{
-  /**
-   * next pointer for DLL
-   */
-  struct MessageQueue *next;
-
-  /**
-   * prev pointer for DLL
-   */
-  struct MessageQueue *prev;
-
-  /**
-   * The message to be sent
-   */
-  struct GNUNET_MessageHeader *msg;
-};
-
-
-/**
  * Context to be associated with each client
  */
 struct ClientCtx
@@ -105,22 +83,8 @@ struct ClientCtx
   /**
    * The client handle
    */
-  struct GNUNET_SERVER_Client *client;
-
-  /**
-   * the transmission handle
-   */
-  struct GNUNET_SERVER_TransmitHandle *tx;
+  struct GNUNET_SERVICE_Client *client;
 
-  /**
-   * message queue head
-   */
-  struct MessageQueue *mq_head;
-
-  /**
-   * message queue tail
-   */
-  struct MessageQueue *mq_tail;
 };
 
 
@@ -169,7 +133,7 @@ struct Barrier
   /**
    * The client handle to the master controller
    */
-  struct GNUNET_SERVER_Client *mc;
+  struct GNUNET_SERVICE_Client *mc;
 
   /**
    * The name of the barrier
@@ -199,7 +163,7 @@ struct Barrier
   /**
    * Identifier for the timeout task
    */
-  struct GNUNET_SCHEDULER_Task * tout_task;
+  struct GNUNET_SCHEDULER_Task *tout_task;
 
   /**
    * The status of this barrier
@@ -247,102 +211,7 @@ static struct GNUNET_CONTAINER_MultiHashMap *barrier_map;
 /**
  * Service context
  */
-static struct GNUNET_SERVICE_Context *ctx;
-
-
-/**
- * Function called to notify a client about the connection
- * begin ready to queue more data.  "buf" will be
- * NULL and "size" zero if the connection was closed for
- * writing in the meantime.
- *
- * @param cls client context
- * @param size number of bytes available in buf
- * @param buf where the callee should write the message
- * @return number of bytes written to buf
- */
-static size_t
-transmit_ready_cb (void *cls, size_t size, void *buf)
-{
-  struct ClientCtx *ctx = cls;
-  struct GNUNET_SERVER_Client *client = ctx->client;
-  struct MessageQueue *mq;
-  struct GNUNET_MessageHeader *msg;
-  size_t wrote;
-
-  ctx->tx = NULL;
-  if ((0 == size) || (NULL == buf))
-  {
-    GNUNET_assert (NULL != ctx->client);
-    GNUNET_SERVER_client_drop (ctx->client);
-    ctx->client = NULL;
-    return 0;
-  }
-  mq = ctx->mq_head;
-  msg = mq->msg;
-  wrote = ntohs (msg->size);
-  GNUNET_assert (size >= wrote);
-  GNUNET_memcpy (buf, msg, wrote);
-  GNUNET_CONTAINER_DLL_remove (ctx->mq_head, ctx->mq_tail, mq);
-  GNUNET_free (mq->msg);
-  GNUNET_free (mq);
-  if (NULL != (mq = ctx->mq_head))
-    ctx->tx = GNUNET_SERVER_notify_transmit_ready (client, ntohs (msg->size),
-                                                  MESSAGE_SEND_TIMEOUT (30),
-                                                  &transmit_ready_cb, ctx);
-  return wrote;
-}
-
-
-/**
- * Queue a message into a clients message queue
- *
- * @param ctx the context associated with the client
- * @param msg the message to queue.  Will be consumed
- */
-static void
-queue_message (struct ClientCtx *ctx, struct GNUNET_MessageHeader *msg)
-{
-  struct MessageQueue *mq;
-  struct GNUNET_SERVER_Client *client = ctx->client;
-
-  mq = GNUNET_new (struct MessageQueue);
-  mq->msg = msg;
-  LOG_DEBUG ("Queueing message of type %u, size %u for sending\n",
-             ntohs (msg->type), ntohs (msg->size));
-  GNUNET_CONTAINER_DLL_insert_tail (ctx->mq_head, ctx->mq_tail, mq);
-  if (NULL == ctx->tx)
-   ctx->tx = GNUNET_SERVER_notify_transmit_ready (client, ntohs (msg->size),
-                                                  MESSAGE_SEND_TIMEOUT (30),
-                                                  &transmit_ready_cb, ctx);
-}
-
-
-/**
- * Function to cleanup client context data structure
- *
- * @param ctx the client context data structure
- */
-static void
-cleanup_clientctx (struct ClientCtx *ctx)
-{
-  struct MessageQueue *mq;
-
-  if (NULL != ctx->client)
-  {
-    GNUNET_SERVER_client_set_user_context_ (ctx->client, NULL, 0);
-    GNUNET_SERVER_client_drop (ctx->client);
-  }
-  if (NULL != ctx->tx)
-    GNUNET_SERVER_notify_transmit_ready_cancel (ctx->tx);
-  if (NULL != (mq = ctx->mq_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (ctx->mq_head, ctx->mq_tail, mq);
-    GNUNET_free (mq->msg);
-    GNUNET_free (mq);
-  }
-  GNUNET_free (ctx);
-}
+static struct GNUNET_SERVICE_Handle *ctx;
 
 
 /**
@@ -356,16 +225,18 @@ remove_barrier (struct Barrier *barrier)
 {
   struct ClientCtx *ctx;
 
-  GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (barrier_map,
-                                                                    &barrier->hash,
-                                                                    barrier));
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_remove (barrier_map,
+                                                       &barrier->hash,
+                                                       barrier));
   while (NULL != (ctx = barrier->head))
   {
-    GNUNET_CONTAINER_DLL_remove (barrier->head, barrier->tail, ctx);
-    cleanup_clientctx (ctx);
+    GNUNET_CONTAINER_DLL_remove (barrier->head,
+                                 barrier->tail,
+                                 ctx);
+    GNUNET_free (ctx);
   }
   GNUNET_free (barrier->name);
-  GNUNET_SERVER_client_drop (barrier->mc);
   GNUNET_free (barrier);
 }
 
@@ -383,7 +254,9 @@ cancel_wrappers (struct Barrier *barrier)
   while (NULL != (wrapper = barrier->whead))
   {
     GNUNET_TESTBED_barrier_cancel (wrapper->hbarrier);
-    GNUNET_CONTAINER_DLL_remove (barrier->whead, barrier->wtail, wrapper);
+    GNUNET_CONTAINER_DLL_remove (barrier->whead,
+                                 barrier->wtail,
+                                 wrapper);
     GNUNET_free (wrapper);
   }
 }
@@ -399,29 +272,33 @@ cancel_wrappers (struct Barrier *barrier)
  *   status=GNUNET_TESTBED_BARRIERSTATUS_ERROR
  */
 static void
-send_client_status_msg (struct GNUNET_SERVER_Client *client,
+send_client_status_msg (struct GNUNET_SERVICE_Client *client,
                         const char *name,
                         enum GNUNET_TESTBED_BarrierStatus status,
                         const char *emsg)
 {
+  struct GNUNET_MQ_Envelope *env;
   struct GNUNET_TESTBED_BarrierStatusMsg *msg;
   size_t name_len;
-  uint16_t msize;
-
-  GNUNET_assert ((NULL == emsg) || (GNUNET_TESTBED_BARRIERSTATUS_ERROR == status));
-  name_len = strlen (name);
-  msize = sizeof (struct GNUNET_TESTBED_BarrierStatusMsg)
-      + (name_len + 1)
-      + ((NULL == emsg) ? 0 : (strlen (emsg) + 1));
-  msg = GNUNET_malloc (msize);
-  msg->header.size = htons (msize);
-  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS);
+  size_t err_len;
+
+  GNUNET_assert ( (NULL == emsg) ||
+                  (GNUNET_TESTBED_BARRIERSTATUS_ERROR == status) );
+  name_len = strlen (name) + 1;
+  err_len = ((NULL == emsg) ? 0 : (strlen (emsg) + 1));
+  env = GNUNET_MQ_msg_extra (msg,
+                             name_len + err_len,
+                             GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS);
   msg->status = htons (status);
-  msg->name_len = htons ((uint16_t) name_len);
-  GNUNET_memcpy (msg->data, name, name_len);
-  if (NULL != emsg)
-    GNUNET_memcpy (msg->data + name_len + 1, emsg, strlen (emsg));
-  GST_queue_message (client, &msg->header);
+  msg->name_len = htons ((uint16_t) name_len - 1);
+  GNUNET_memcpy (msg->data,
+                 name,
+                 name_len);
+  GNUNET_memcpy (msg->data + name_len,
+                 emsg,
+                 err_len);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                  env);
 }
 
 
@@ -433,82 +310,119 @@ send_client_status_msg (struct GNUNET_SERVER_Client *client,
  *   status=GNUNET_TESTBED_BARRIERSTATUS_ERROR
  */
 static void
-send_barrier_status_msg (struct Barrier *barrier, const char *emsg)
+send_barrier_status_msg (struct Barrier *barrier,
+                         const char *emsg)
 {
   GNUNET_assert (0 != barrier->status);
-  send_client_status_msg (barrier->mc, barrier->name, barrier->status, emsg);
+  send_client_status_msg (barrier->mc,
+                          barrier->name,
+                          barrier->status,
+                          emsg);
 }
 
 
 /**
- * Message handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT messages.  This
+ * Check #GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT messages.
+ *
+ * @param cls identification of the client
+ * @param message the actual message
+ */
+static int
+check_barrier_wait (void *cls,
+                     const struct GNUNET_TESTBED_BarrierWait *msg)
+{
+  return GNUNET_OK; /* always well-formed */
+}
+
+
+/**
+ * Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT messages.  This
  * message should come from peers or a shared helper service using the
  * testbed-barrier client API (@see gnunet_testbed_barrier_service.h)
  *
  * This handler is queued in the main service and will handle the messages sent
  * either from the testbed driver or from a high level controller
  *
- * @param cls NULL
- * @param client identification of the client
+ * @param cls identification of the client
  * @param message the actual message
  */
 static void
-handle_barrier_wait (void *cls, struct GNUNET_SERVER_Client *client,
-                     const struct GNUNET_MessageHeader *message)
+handle_barrier_wait (void *cls,
+                     const struct GNUNET_TESTBED_BarrierWait *msg)
 {
-  const struct GNUNET_TESTBED_BarrierWait *msg;
+  struct ClientCtx *client_ctx = cls;
   struct Barrier *barrier;
   char *name;
-  struct ClientCtx *client_ctx;
   struct GNUNET_HashCode key;
   size_t name_len;
   uint16_t msize;
 
-  msize = ntohs (message->size);
-  if (msize <= sizeof (struct GNUNET_TESTBED_BarrierWait))
-  {
-    GNUNET_break_op (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-    return;
-  }
+  msize = ntohs (msg->header.size);
   if (NULL == barrier_map)
   {
     GNUNET_break (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    GNUNET_SERVICE_client_drop (client_ctx->client);
     return;
   }
-  msg = (const struct GNUNET_TESTBED_BarrierWait *) message;
   name_len = msize - sizeof (struct GNUNET_TESTBED_BarrierWait);
   name = GNUNET_malloc (name_len + 1);
   name[name_len] = '\0';
-  GNUNET_memcpy (name, msg->name, name_len);
-  LOG_DEBUG ("Received BARRIER_WAIT for barrier `%s'\n", name);
-  GNUNET_CRYPTO_hash (name, name_len, &key);
+  GNUNET_memcpy (name,
+                 msg->name,
+                 name_len);
+  LOG_DEBUG ("Received BARRIER_WAIT for barrier `%s'\n",
+             name);
+  GNUNET_CRYPTO_hash (name,
+                      name_len,
+                      &key);
   GNUNET_free (name);
   if (NULL == (barrier = GNUNET_CONTAINER_multihashmap_get (barrier_map, &key)))
   {
     GNUNET_break (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    GNUNET_SERVICE_client_drop (client_ctx->client);
     return;
   }
-  client_ctx = GNUNET_SERVER_client_get_user_context (client, struct ClientCtx);
-  if (NULL == client_ctx)
+  if (NULL != client_ctx->barrier)
   {
-    client_ctx = GNUNET_new (struct ClientCtx);
-    client_ctx->client = client;
-    GNUNET_SERVER_client_keep (client);
-    client_ctx->barrier = barrier;
-    GNUNET_CONTAINER_DLL_insert_tail (barrier->head, barrier->tail, client_ctx);
-    GNUNET_SERVER_client_set_user_context (client, client_ctx);
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (client_ctx->client);
+    return;
   }
+  client_ctx->barrier = barrier;
+  GNUNET_CONTAINER_DLL_insert_tail (barrier->head,
+                                    barrier->tail,
+                                    client_ctx);
   barrier->nreached++;
-  if ((barrier->num_wbarriers_reached == barrier->num_wbarriers)
-        && (LOCAL_QUORUM_REACHED (barrier)))
+  if ( (barrier->num_wbarriers_reached == barrier->num_wbarriers) &&
+       (LOCAL_QUORUM_REACHED (barrier)) )
   {
     barrier->status = GNUNET_TESTBED_BARRIERSTATUS_CROSSED;
-    send_barrier_status_msg (barrier, NULL);
+    send_barrier_status_msg (barrier,
+                             NULL);
   }
-  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+  GNUNET_SERVICE_client_continue (client_ctx->client);
+}
+
+
+/**
+ * Function called when a client connects to the testbed-barrier service.
+ *
+ * @param cls NULL
+ * @param client the connecting client
+ * @param mq queue to talk to @a client
+ * @return our `struct ClientCtx`
+ */
+static void *
+connect_cb (void *cls,
+            struct GNUNET_SERVICE_Client *client,
+            struct GNUNET_MQ_Handle *mq)
+{
+  struct ClientCtx *client_ctx;
+
+  LOG_DEBUG ("Client connected to testbed-barrier service\n");
+  client_ctx = GNUNET_new (struct ClientCtx);
+  client_ctx->client = client;
+  return client_ctx;
 }
 
 
@@ -521,16 +435,22 @@ handle_barrier_wait (void *cls, struct GNUNET_SERVER_Client *client,
  *        for the last call when the server is destroyed
  */
 static void
-disconnect_cb (void *cls, struct GNUNET_SERVER_Client *client)
+disconnect_cb (void *cls,
+               struct GNUNET_SERVICE_Client *client,
+               void *app_ctx)
 {
-  struct ClientCtx *client_ctx;
+  struct ClientCtx *client_ctx = app_ctx;
+  struct Barrier *barrier = client_ctx->barrier;
 
-  if (NULL == client)
-    return;
-  client_ctx = GNUNET_SERVER_client_get_user_context (client, struct ClientCtx);
-  if (NULL == client_ctx)
-    return;
-  cleanup_clientctx (client_ctx);
+  if (NULL != barrier)
+  {
+    GNUNET_CONTAINER_DLL_remove (barrier->head,
+                                 barrier->tail,
+                                 client_ctx);
+    client_ctx->barrier = NULL;
+  }
+  GNUNET_free (client_ctx);
+  LOG_DEBUG ("Client disconnected from testbed-barrier service\n");
 }
 
 
@@ -542,18 +462,23 @@ disconnect_cb (void *cls, struct GNUNET_SERVER_Client *client)
 void
 GST_barriers_init (struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  static const struct GNUNET_SERVER_MessageHandler message_handlers[] = {
-    {&handle_barrier_wait, NULL, GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT, 0},
-    {NULL, NULL, 0, 0}
+  struct GNUNET_MQ_MessageHandler message_handlers[] = {
+    GNUNET_MQ_hd_var_size (barrier_wait,
+                           GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT,
+                           struct GNUNET_TESTBED_BarrierWait,
+                           NULL),
+    GNUNET_MQ_handler_end ()
   };
-  struct GNUNET_SERVER_Handle *srv;
-
-  barrier_map = GNUNET_CONTAINER_multihashmap_create (3, GNUNET_YES);
-  ctx = GNUNET_SERVICE_start ("testbed-barrier", cfg,
-                              GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN);
-  srv = GNUNET_SERVICE_get_server (ctx);
-  GNUNET_SERVER_add_handlers (srv, message_handlers);
-  GNUNET_SERVER_disconnect_notify (srv, &disconnect_cb, NULL);
+
+  LOG_DEBUG ("Launching testbed-barrier service\n");
+  barrier_map = GNUNET_CONTAINER_multihashmap_create (3,
+                                                      GNUNET_YES);
+  ctx = GNUNET_SERVICE_starT ("testbed-barrier",
+                              cfg,
+                              &connect_cb,
+                              &disconnect_cb,
+                              NULL,
+                              message_handlers);
 }
 
 
@@ -594,7 +519,7 @@ GST_barriers_destroy ()
                                                         NULL));
   GNUNET_CONTAINER_multihashmap_destroy (barrier_map);
   GNUNET_assert (NULL != ctx);
-  GNUNET_SERVICE_stop (ctx);
+  GNUNET_SERVICE_stoP (ctx);
 }
 
 
@@ -606,13 +531,14 @@ GST_barriers_destroy ()
  * @param cls the closure given to GNUNET_TESTBED_barrier_init()
  * @param name the name of the barrier
  * @param b_ the barrier handle
- * @param status status of the barrier; GNUNET_OK if the barrier is crossed;
- *   GNUNET_SYSERR upon error
- * @param emsg if the status were to be GNUNET_SYSERR, this parameter has the
+ * @param status status of the barrier; #GNUNET_OK if the barrier is crossed;
+ *   #GNUNET_SYSERR upon error
+ * @param emsg if the status were to be #GNUNET_SYSERR, this parameter has the
  *   error messsage
  */
 static void
-wbarrier_status_cb (void *cls, const char *name,
+wbarrier_status_cb (void *cls,
+                    const char *name,
                     struct GNUNET_TESTBED_Barrier *b_,
                     enum GNUNET_TESTBED_BarrierStatus status,
                     const char *emsg)
@@ -622,14 +548,17 @@ wbarrier_status_cb (void *cls, const char *name,
 
   GNUNET_assert (b_ == wrapper->hbarrier);
   wrapper->hbarrier = NULL;
-  GNUNET_CONTAINER_DLL_remove (barrier->whead, barrier->wtail, wrapper);
+  GNUNET_CONTAINER_DLL_remove (barrier->whead,
+                               barrier->wtail,
+                               wrapper);
   GNUNET_free (wrapper);
   switch (status)
   {
   case GNUNET_TESTBED_BARRIERSTATUS_ERROR:
     LOG (GNUNET_ERROR_TYPE_ERROR,
          "Initialising barrier `%s' failed at a sub-controller: %s\n",
-         barrier->name, (NULL != emsg) ? emsg : "NULL");
+         barrier->name,
+         (NULL != emsg) ? emsg : "NULL");
     cancel_wrappers (barrier);
     if (NULL == emsg)
       emsg = "Initialisation failed at a sub-controller";
@@ -686,23 +615,38 @@ fwd_tout_barrier_init (void *cls)
 }
 
 
+
+/**
+ * Check #GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT messages.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+int
+check_barrier_init (void *cls,
+                    const struct GNUNET_TESTBED_BarrierInit *msg)
+{
+  return GNUNET_OK; /* always well-formed */
+}
+
+
 /**
- * Message handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT messages.  This
+ * Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT messages.  This
  * message should always come from a parent controller or the testbed API if we
  * are the root controller.
  *
  * This handler is queued in the main service and will handle the messages sent
  * either from the testbed driver or from a high level controller
  *
- * @param cls NULL
- * @param client identification of the client
- * @param message the actual message
+ * @param cls identification of the client
+ * @param msg the actual message
  */
 void
-GST_handle_barrier_init (void *cls, struct GNUNET_SERVER_Client *client,
-                         const struct GNUNET_MessageHeader *message)
+handle_barrier_init (void *cls,
+                     const struct GNUNET_TESTBED_BarrierInit *msg)
 {
-  const struct GNUNET_TESTBED_BarrierInit *msg;
+  struct GNUNET_SERVICE_Client *client = cls;
   char *name;
   struct Barrier *barrier;
   struct Slave *slave;
@@ -715,49 +659,45 @@ GST_handle_barrier_init (void *cls, struct GNUNET_SERVER_Client *client,
   if (NULL == GST_context)
   {
     GNUNET_break_op (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    GNUNET_SERVICE_client_drop (client);
     return;
   }
   if (client != GST_context->client)
   {
     GNUNET_break_op (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    GNUNET_SERVICE_client_drop (client);
     return;
   }
-  msize = ntohs (message->size);
-  if (msize <= sizeof (struct GNUNET_TESTBED_BarrierInit))
-  {
-    GNUNET_break_op (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-    return;
-  }
-  msg = (const struct GNUNET_TESTBED_BarrierInit *) message;
+  msize = ntohs (msg->header.size);
   name_len = (size_t) msize - sizeof (struct GNUNET_TESTBED_BarrierInit);
   name = GNUNET_malloc (name_len + 1);
   GNUNET_memcpy (name, msg->name, name_len);
   GNUNET_CRYPTO_hash (name, name_len, &hash);
-  LOG_DEBUG ("Received BARRIER_INIT for barrier `%s'\n", name);
-  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (barrier_map, &hash))
+  LOG_DEBUG ("Received BARRIER_INIT for barrier `%s'\n",
+             name);
+  if (GNUNET_YES ==
+      GNUNET_CONTAINER_multihashmap_contains (barrier_map,
+                                              &hash))
   {
-
-    send_client_status_msg (client, name, GNUNET_TESTBED_BARRIERSTATUS_ERROR,
+    send_client_status_msg (client,
+                            name,
+                            GNUNET_TESTBED_BARRIERSTATUS_ERROR,
                             "A barrier with the same name already exists");
     GNUNET_free (name);
-    GNUNET_SERVER_receive_done (client, GNUNET_OK);
+    GNUNET_SERVICE_client_continue (client);
     return;
   }
   barrier = GNUNET_new (struct Barrier);
-  GNUNET_memcpy (&barrier->hash, &hash, sizeof (struct GNUNET_HashCode));
+  barrier->hash = hash;
   barrier->quorum = msg->quorum;
   barrier->name = name;
   barrier->mc = client;
-  GNUNET_SERVER_client_keep (client);
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONTAINER_multihashmap_put (barrier_map,
                                                     &barrier->hash,
                                                     barrier,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
-  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+  GNUNET_SERVICE_client_continue (client);
   /* Propagate barrier init to subcontrollers */
   for (cnt = 0; cnt < GST_slave_list_size; cnt++)
   {
@@ -770,7 +710,9 @@ GST_handle_barrier_init (void *cls, struct GNUNET_SERVER_Client *client,
     }
     wrapper = GNUNET_new (struct WBarrier);
     wrapper->barrier = barrier;
-    GNUNET_CONTAINER_DLL_insert_tail (barrier->whead, barrier->wtail, wrapper);
+    GNUNET_CONTAINER_DLL_insert_tail (barrier->whead,
+                                      barrier->wtail,
+                                      wrapper);
     wrapper->hbarrier = GNUNET_TESTBED_barrier_init_ (slave->controller,
                                                       barrier->name,
                                                       barrier->quorum,
@@ -792,22 +734,36 @@ GST_handle_barrier_init (void *cls, struct GNUNET_SERVER_Client *client,
 
 
 /**
- * Message handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL messages.  This
+ * Check #GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL messages.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+int
+check_barrier_cancel (void *cls,
+                      const struct GNUNET_TESTBED_BarrierCancel *msg)
+{
+  return GNUNET_OK; /* all are well-formed */
+}
+
+
+/**
+ * Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL messages.  This
  * message should always come from a parent controller or the testbed API if we
  * are the root controller.
  *
  * This handler is queued in the main service and will handle the messages sent
  * either from the testbed driver or from a high level controller
  *
- * @param cls NULL
- * @param client identification of the client
- * @param message the actual message
+ * @param cls identification of the client
+ * @param msg the actual message
  */
 void
-GST_handle_barrier_cancel (void *cls, struct GNUNET_SERVER_Client *client,
-                           const struct GNUNET_MessageHeader *message)
+handle_barrier_cancel (void *cls,
+                       const struct GNUNET_TESTBED_BarrierCancel *msg)
 {
-  const struct GNUNET_TESTBED_BarrierCancel *msg;
+  struct GNUNET_SERVICE_Client *client = cls;
   char *name;
   struct Barrier *barrier;
   struct GNUNET_HashCode hash;
@@ -817,119 +773,140 @@ GST_handle_barrier_cancel (void *cls, struct GNUNET_SERVER_Client *client,
   if (NULL == GST_context)
   {
     GNUNET_break_op (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    GNUNET_SERVICE_client_drop (client);
     return;
   }
   if (client != GST_context->client)
   {
     GNUNET_break_op (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    GNUNET_SERVICE_client_drop (client);
     return;
   }
-  msize = ntohs (message->size);
-  if (msize <= sizeof (struct GNUNET_TESTBED_BarrierCancel))
-  {
-    GNUNET_break_op (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-    return;
-  }
-  msg = (const struct GNUNET_TESTBED_BarrierCancel *) message;
+  msize = ntohs (msg->header.size);
   name_len = msize - sizeof (struct GNUNET_TESTBED_BarrierCancel);
   name = GNUNET_malloc (name_len + 1);
-  GNUNET_memcpy (name, msg->name, name_len);
-  GNUNET_CRYPTO_hash (name, name_len, &hash);
-  if (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (barrier_map, &hash))
+  GNUNET_memcpy (name,
+                 msg->name,
+                 name_len);
+  LOG_DEBUG ("Received BARRIER_CANCEL for barrier `%s'\n",
+             name);
+  GNUNET_CRYPTO_hash (name,
+                      name_len,
+                      &hash);
+  if (GNUNET_NO ==
+      GNUNET_CONTAINER_multihashmap_contains (barrier_map,
+                                              &hash))
   {
     GNUNET_break_op (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    GNUNET_SERVICE_client_drop (client);
     return;
   }
-  barrier = GNUNET_CONTAINER_multihashmap_get (barrier_map, &hash);
+  barrier = GNUNET_CONTAINER_multihashmap_get (barrier_map,
+                                               &hash);
   GNUNET_assert (NULL != barrier);
   cancel_wrappers (barrier);
   remove_barrier (barrier);
-  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
 /**
- * Message handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS messages.
+ * Check #GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS messages.
+ *
+ * @param cls identification of the client
+ * @param msg the actual message
+ * @return #GNUNET_OK if @a msg is well-formed
+ */
+int
+check_barrier_status (void *cls,
+                      const struct GNUNET_TESTBED_BarrierStatusMsg *msg)
+{
+  uint16_t msize;
+  uint16_t name_len;
+  const char *name;
+  enum GNUNET_TESTBED_BarrierStatus status;
+
+  msize = ntohs (msg->header.size) - sizeof (*msg);
+  status = ntohs (msg->status);
+  if (GNUNET_TESTBED_BARRIERSTATUS_CROSSED != status)
+  {
+    GNUNET_break_op (0);        /* current we only expect BARRIER_CROSSED
+                                   status message this way */
+    return GNUNET_SYSERR;
+  }
+  name = msg->data;
+  name_len = ntohs (msg->name_len);
+  if ((name_len + 1) != msize)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  if ('\0' != name[name_len])
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS messages.
  * This handler is queued in the main service and will handle the messages sent
  * either from the testbed driver or from a high level controller
  *
- * @param cls NULL
- * @param client identification of the client
- * @param message the actual message
+ * @param cls identification of the client
+ * @param msg the actual message
  */
 void
-GST_handle_barrier_status (void *cls,
-                           struct GNUNET_SERVER_Client *client,
-                           const struct GNUNET_MessageHeader *message)
+handle_barrier_status (void *cls,
+                       const struct GNUNET_TESTBED_BarrierStatusMsg *msg)
 {
-  const struct GNUNET_TESTBED_BarrierStatusMsg *msg;
+  struct GNUNET_SERVICE_Client *client = cls;
   struct Barrier *barrier;
   struct ClientCtx *client_ctx;
   const char *name;
   struct GNUNET_HashCode key;
-  enum GNUNET_TESTBED_BarrierStatus status;
-  uint16_t msize;
   uint16_t name_len;
+  struct GNUNET_MQ_Envelope *env;
 
   if (NULL == GST_context)
   {
     GNUNET_break_op (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    GNUNET_SERVICE_client_drop (client);
     return;
   }
   if (client != GST_context->client)
   {
     GNUNET_break_op (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-    return;
-  }
-  msize = ntohs (message->size);
-  if (msize <= sizeof (struct GNUNET_TESTBED_BarrierStatusMsg))
-  {
-    GNUNET_break_op (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-    return;
-  }
-  msg = (const struct GNUNET_TESTBED_BarrierStatusMsg *) message;
-  status = ntohs (msg->status);
-  if (GNUNET_TESTBED_BARRIERSTATUS_CROSSED != status)
-  {
-    GNUNET_break_op (0);        /* current we only expect BARRIER_CROSSED
-                                   status message this way */
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    GNUNET_SERVICE_client_drop (client);
     return;
   }
   name = msg->data;
   name_len = ntohs (msg->name_len);
-  if ((sizeof (struct GNUNET_TESTBED_BarrierStatusMsg) + name_len + 1) != msize)
-  {
-    GNUNET_break_op (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-    return;
-  }
-  if ('\0' != name[name_len])
-  {
-    GNUNET_break_op (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-    return;
-  }
-  GNUNET_CRYPTO_hash (name, name_len, &key);
-  barrier = GNUNET_CONTAINER_multihashmap_get (barrier_map, &key);
+  LOG_DEBUG ("Received BARRIER_STATUS for barrier `%s'\n",
+             name);
+  GNUNET_CRYPTO_hash (name,
+                      name_len,
+                      &key);
+  barrier = GNUNET_CONTAINER_multihashmap_get (barrier_map,
+                                               &key);
   if (NULL == barrier)
   {
     GNUNET_break_op (0);
-    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    GNUNET_SERVICE_client_drop (client);
     return;
   }
-  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+  GNUNET_SERVICE_client_continue (client);
   while (NULL != (client_ctx = barrier->head)) /* Notify peers */
   {
-    queue_message (client_ctx, GNUNET_copy_message (message));
-    GNUNET_CONTAINER_DLL_remove (barrier->head, barrier->tail, client_ctx);
+    env = GNUNET_MQ_msg_copy (&msg->header);
+    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                    env);
+    GNUNET_CONTAINER_DLL_remove (barrier->head,
+                                 barrier->tail,
+                                 client_ctx);
+    client_ctx->barrier = NULL;
   }
 }