1 files changed, 494 insertions, 488 deletions

diff --git a/src/testbed/gnunet-service-testbed.c b/src/testbed/gnunet-service-testbed.c
index 26f1a9c26..b34550339 100644
--- a/src/testbed/gnunet-service-testbed.c
+++ b/src/testbed/gnunet-service-testbed.c
@@ -96,18 +96,18 @@ static char *hostname;
  *           already in use
  */
 static int
-host_list_add(struct GNUNET_TESTBED_Host *host)
+host_list_add (struct GNUNET_TESTBED_Host *host)
 {
   uint32_t host_id;
 
-  host_id = GNUNET_TESTBED_host_get_id_(host);
+  host_id = GNUNET_TESTBED_host_get_id_ (host);
   if (GST_host_list_size <= host_id)
-    GST_array_grow_large_enough(GST_host_list, GST_host_list_size, host_id);
+    GST_array_grow_large_enough (GST_host_list, GST_host_list_size, host_id);
   if (NULL != GST_host_list[host_id])
-    {
-      LOG_DEBUG("A host with id: %u already exists\n", host_id);
-      return GNUNET_SYSERR;
-    }
+  {
+    LOG_DEBUG ("A host with id: %u already exists\n", host_id);
+    return GNUNET_SYSERR;
+  }
   GST_host_list[host_id] = host;
   return GNUNET_OK;
 }
@@ -121,25 +121,25 @@ host_list_add(struct GNUNET_TESTBED_Host *host)
  * @param emsg the error message; can be NULL
  */
 void
-GST_send_operation_fail_msg(struct GNUNET_SERVICE_Client *client,
-                            uint64_t operation_id,
-                            const char *emsg)
+GST_send_operation_fail_msg (struct GNUNET_SERVICE_Client *client,
+                             uint64_t operation_id,
+                             const char *emsg)
 {
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_TESTBED_OperationFailureEventMessage *msg;
   uint16_t emsg_len;
 
-  emsg_len = (NULL == emsg) ? 0 : strlen(emsg) + 1;
-  env = GNUNET_MQ_msg_extra(msg,
-                            emsg_len,
-                            GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT);
-  msg->event_type = htonl(GNUNET_TESTBED_ET_OPERATION_FINISHED);
-  msg->operation_id = GNUNET_htonll(operation_id);
-  GNUNET_memcpy(&msg[1],
-                emsg,
-                emsg_len);
-  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client),
-                 env);
+  emsg_len = (NULL == emsg) ? 0 : strlen (emsg) + 1;
+  env = GNUNET_MQ_msg_extra (msg,
+                             emsg_len,
+                             GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT);
+  msg->event_type = htonl (GNUNET_TESTBED_ET_OPERATION_FINISHED);
+  msg->operation_id = GNUNET_htonll (operation_id);
+  GNUNET_memcpy (&msg[1],
+                 emsg,
+                 emsg_len);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                  env);
 }
 
 
@@ -150,18 +150,18 @@ GST_send_operation_fail_msg(struct GNUNET_SERVICE_Client *client,
  * @param operation_id the id of the operation which was successful
  */
 void
-GST_send_operation_success_msg(struct GNUNET_SERVICE_Client *client,
-                               uint64_t operation_id)
+GST_send_operation_success_msg (struct GNUNET_SERVICE_Client *client,
+                                uint64_t operation_id)
 {
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_TESTBED_GenericOperationSuccessEventMessage *msg;
 
-  env = GNUNET_MQ_msg(msg,
-                      GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS);
-  msg->operation_id = GNUNET_htonll(operation_id);
-  msg->event_type = htonl(GNUNET_TESTBED_ET_OPERATION_FINISHED);
-  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client),
-                 env);
+  env = GNUNET_MQ_msg (msg,
+                       GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS);
+  msg->operation_id = GNUNET_htonll (operation_id);
+  msg->event_type = htonl (GNUNET_TESTBED_ET_OPERATION_FINISHED);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                  env);
 }
 
 
@@ -172,8 +172,8 @@ GST_send_operation_success_msg(struct GNUNET_SERVICE_Client *client,
  * @param emsg the error message; NULL if host registration is successful
  */
 static void
-hr_completion(void *cls,
-              const char *emsg);
+hr_completion (void *cls,
+               const char *emsg);
 
 
 /**
@@ -183,21 +183,21 @@ hr_completion(void *cls,
  *          for host registrations
  */
 static void
-register_next_host(struct Slave *slave)
+register_next_host (struct Slave *slave)
 {
   struct HostRegistration *hr;
 
   hr = slave->hr_dll_head;
-  GNUNET_assert(NULL != hr);
-  GNUNET_assert(NULL == slave->rhandle);
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "Registering host %u at %u\n",
-      GNUNET_TESTBED_host_get_id_(hr->host),
-      GNUNET_TESTBED_host_get_id_(GST_host_list[slave->host_id]));
+  GNUNET_assert (NULL != hr);
+  GNUNET_assert (NULL == slave->rhandle);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Registering host %u at %u\n",
+       GNUNET_TESTBED_host_get_id_ (hr->host),
+       GNUNET_TESTBED_host_get_id_ (GST_host_list[slave->host_id]));
   slave->rhandle
-    = GNUNET_TESTBED_register_host(slave->controller,
-                                   hr->host,
-                                   hr_completion,
-                                   slave);
+    = GNUNET_TESTBED_register_host (slave->controller,
+                                    hr->host,
+                                    hr_completion,
+                                    slave);
 }
 
 
@@ -208,28 +208,28 @@ register_next_host(struct Slave *slave)
  * @param emsg the error message; NULL if host registration is successful
  */
 static void
-hr_completion(void *cls,
-              const char *emsg)
+hr_completion (void *cls,
+               const char *emsg)
 {
   struct Slave *slave = cls;
   struct HostRegistration *hr;
 
   slave->rhandle = NULL;
   hr = slave->hr_dll_head;
-  GNUNET_assert(NULL != hr);
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Registering host %u at %u successful\n",
-      GNUNET_TESTBED_host_get_id_(hr->host),
-      GNUNET_TESTBED_host_get_id_(GST_host_list[slave->host_id]));
-  GNUNET_CONTAINER_DLL_remove(slave->hr_dll_head,
-                              slave->hr_dll_tail,
-                              hr);
+  GNUNET_assert (NULL != hr);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Registering host %u at %u successful\n",
+       GNUNET_TESTBED_host_get_id_ (hr->host),
+       GNUNET_TESTBED_host_get_id_ (GST_host_list[slave->host_id]));
+  GNUNET_CONTAINER_DLL_remove (slave->hr_dll_head,
+                               slave->hr_dll_tail,
+                               hr);
   if (NULL != hr->cb)
-    hr->cb(hr->cb_cls,
-           emsg);
-  GNUNET_free(hr);
+    hr->cb (hr->cb_cls,
+            emsg);
+  GNUNET_free (hr);
   if (NULL != slave->hr_dll_head)
-    register_next_host(slave);
+    register_next_host (slave);
 }
 
 
@@ -243,28 +243,28 @@ hr_completion(void *cls,
  * @param host the host which has to be registered
  */
 void
-GST_queue_host_registration(struct Slave *slave,
-                            GNUNET_TESTBED_HostRegistrationCompletion cb,
-                            void *cb_cls,
-                            struct GNUNET_TESTBED_Host *host)
+GST_queue_host_registration (struct Slave *slave,
+                             GNUNET_TESTBED_HostRegistrationCompletion cb,
+                             void *cb_cls,
+                             struct GNUNET_TESTBED_Host *host)
 {
   struct HostRegistration *hr;
   int call_register;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "Queueing host registration for host %u at %u\n",
-      GNUNET_TESTBED_host_get_id_(host),
-      GNUNET_TESTBED_host_get_id_(GST_host_list[slave->host_id]));
-  hr = GNUNET_new(struct HostRegistration);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Queueing host registration for host %u at %u\n",
+       GNUNET_TESTBED_host_get_id_ (host),
+       GNUNET_TESTBED_host_get_id_ (GST_host_list[slave->host_id]));
+  hr = GNUNET_new (struct HostRegistration);
   hr->cb = cb;
   hr->cb_cls = cb_cls;
   hr->host = host;
   call_register = (NULL == slave->hr_dll_head) ? GNUNET_YES : GNUNET_NO;
-  GNUNET_CONTAINER_DLL_insert_tail(slave->hr_dll_head,
-                                   slave->hr_dll_tail,
-                                   hr);
+  GNUNET_CONTAINER_DLL_insert_tail (slave->hr_dll_head,
+                                    slave->hr_dll_tail,
+                                    hr);
   if (GNUNET_YES == call_register)
-    register_next_host(slave);
+    register_next_host (slave);
 }
 
 
@@ -275,23 +275,23 @@ GST_queue_host_registration(struct Slave *slave,
  * @param msg the message to relay
  */
 void
-GST_forwarded_operation_reply_relay(void *cls,
-                                    const struct GNUNET_MessageHeader *msg)
+GST_forwarded_operation_reply_relay (void *cls,
+                                     const struct GNUNET_MessageHeader *msg)
 {
   struct ForwardedOperationContext *fopc = cls;
   struct GNUNET_MQ_Envelope *env;
 
-  LOG_DEBUG("Relaying message with type: %u, size: %u\n",
-            ntohs(msg->type),
-            ntohs(msg->size));
-  env = GNUNET_MQ_msg_copy(msg);
-  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(fopc->client),
-                 env);
-  GNUNET_SCHEDULER_cancel(fopc->timeout_task);
-  GNUNET_CONTAINER_DLL_remove(fopcq_head,
-                              fopcq_tail,
-                              fopc);
-  GNUNET_free(fopc);
+  LOG_DEBUG ("Relaying message with type: %u, size: %u\n",
+             ntohs (msg->type),
+             ntohs (msg->size));
+  env = GNUNET_MQ_msg_copy (msg);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (fopc->client),
+                  env);
+  GNUNET_SCHEDULER_cancel (fopc->timeout_task);
+  GNUNET_CONTAINER_DLL_remove (fopcq_head,
+                               fopcq_tail,
+                               fopc);
+  GNUNET_free (fopc);
 }
 
 
@@ -301,21 +301,21 @@ GST_forwarded_operation_reply_relay(void *cls,
  * @param cls the ForwardedOperationContext
  */
 void
-GST_forwarded_operation_timeout(void *cls)
+GST_forwarded_operation_timeout (void *cls)
 {
   struct ForwardedOperationContext *fopc = cls;
 
   fopc->timeout_task = NULL;
-  GNUNET_TESTBED_forward_operation_msg_cancel_(fopc->opc);
-  LOG(GNUNET_ERROR_TYPE_DEBUG,
-      "A forwarded operation has timed out\n");
-  GST_send_operation_fail_msg(fopc->client,
-                              fopc->operation_id,
-                              "A forwarded operation has timed out");
-  GNUNET_CONTAINER_DLL_remove(fopcq_head,
-                              fopcq_tail,
-                              fopc);
-  GNUNET_free(fopc);
+  GNUNET_TESTBED_forward_operation_msg_cancel_ (fopc->opc);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "A forwarded operation has timed out\n");
+  GST_send_operation_fail_msg (fopc->client,
+                               fopc->operation_id,
+                               "A forwarded operation has timed out");
+  GNUNET_CONTAINER_DLL_remove (fopcq_head,
+                               fopcq_tail,
+                               fopc);
+  GNUNET_free (fopc);
 }
 
 
@@ -329,8 +329,8 @@ GST_forwarded_operation_timeout(void *cls)
  *           upon empty service sharing specification.
  */
 static struct GNUNET_TESTING_SharedService *
-parse_shared_services(char *ss_str,
-                      struct GNUNET_CONFIGURATION_Handle *cfg)
+parse_shared_services (char *ss_str,
+                       struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_TESTING_SharedService ss;
   struct GNUNET_TESTING_SharedService *slist;
@@ -340,41 +340,41 @@ parse_shared_services(char *ss_str,
 
 #define GROW_SS                                 \
   do {                                          \
-      GNUNET_array_grow(slist, n, n + 1);                                  \
-      GNUNET_memcpy(&slist[n - 1], &ss,                                  \
-                    sizeof(struct GNUNET_TESTING_SharedService));       \
-    } while (0)
+    GNUNET_array_grow (slist, n, n + 1);                                  \
+    GNUNET_memcpy (&slist[n - 1], &ss,                                  \
+                   sizeof(struct GNUNET_TESTING_SharedService));       \
+  } while (0)
 
   slist = NULL;
   n = 0;
   ss.cfg = cfg;
-  for (; NULL != (arg = strtok(ss_str, " ")); ss_str = NULL)
+  for (; NULL != (arg = strtok (ss_str, " ")); ss_str = NULL)
+  {
+    ss.service = NULL;
+    ss.share = 0;
+    if (2 != sscanf (arg, "%255[^:]:%u",
+                     service,
+                     &ss.share))
     {
-      ss.service = NULL;
-      ss.share = 0;
-      if (2 != sscanf(arg, "%255[^:]:%u",
-                      service,
-                      &ss.share))
-        {
-          LOG(GNUNET_ERROR_TYPE_WARNING,
-              "Ignoring shared service spec: %s",
-              arg);
-          continue;
-        }
-      LOG_DEBUG("Will be sharing %s service among %u peers\n",
-                service,
-                ss.share);
-      ss.service = GNUNET_strdup(service);
-      GROW_SS;
+      LOG (GNUNET_ERROR_TYPE_WARNING,
+           "Ignoring shared service spec: %s",
+           arg);
+      continue;
     }
+    LOG_DEBUG ("Will be sharing %s service among %u peers\n",
+               service,
+               ss.share);
+    ss.service = GNUNET_strdup (service);
+    GROW_SS;
+  }
   if (NULL != slist)
-    {
-      /* Add trailing NULL block */
-      (void)memset(&ss,
+  {
+    /* Add trailing NULL block */
+    (void) memset (&ss,
                    0,
                    sizeof(struct GNUNET_TESTING_SharedService));
-      GROW_SS;
-    }
+    GROW_SS;
+  }
   return slist;
 #undef GROW_SS
 }
@@ -388,19 +388,19 @@ parse_shared_services(char *ss_str,
  * @return #GNUNET_OK if @a message is well-formed
  */
 static int
-check_init(void *cls,
-           const struct GNUNET_TESTBED_InitMessage *msg)
+check_init (void *cls,
+            const struct GNUNET_TESTBED_InitMessage *msg)
 {
   const char *controller_hostname;
   uint16_t msize;
 
-  msize = ntohs(msg->header.size) - sizeof(struct GNUNET_TESTBED_InitMessage);
-  controller_hostname = (const char *)&msg[1];
+  msize = ntohs (msg->header.size) - sizeof(struct GNUNET_TESTBED_InitMessage);
+  controller_hostname = (const char *) &msg[1];
   if ('\0' != controller_hostname[msize - 1])
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -412,8 +412,8 @@ check_init(void *cls,
  * @param message the actual message
  */
 static void
-handle_init(void *cls,
-            const struct GNUNET_TESTBED_InitMessage *msg)
+handle_init (void *cls,
+             const struct GNUNET_TESTBED_InitMessage *msg)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   struct GNUNET_TESTBED_Host *host;
@@ -423,56 +423,56 @@ handle_init(void *cls,
   unsigned int cnt;
 
   if (NULL != GST_context)
-    {
-      LOG_DEBUG("We are being connected to laterally\n");
-      GNUNET_SERVICE_client_continue(client);
-      return;
-    }
-  controller_hostname = (const char *)&msg[1];
+  {
+    LOG_DEBUG ("We are being connected to laterally\n");
+    GNUNET_SERVICE_client_continue (client);
+    return;
+  }
+  controller_hostname = (const char *) &msg[1];
   ss_str = NULL;
   ss = NULL;
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_get_value_string(GST_config,
-                                            "TESTBED",
-                                            "SHARED_SERVICES",
-                                            &ss_str))
-    {
-      ss = parse_shared_services(ss_str,
-                                 GST_config);
-      GNUNET_free(ss_str);
-      ss_str = NULL;
-    }
-  GST_context = GNUNET_new(struct Context);
+      GNUNET_CONFIGURATION_get_value_string (GST_config,
+                                             "TESTBED",
+                                             "SHARED_SERVICES",
+                                             &ss_str))
+  {
+    ss = parse_shared_services (ss_str,
+                                GST_config);
+    GNUNET_free (ss_str);
+    ss_str = NULL;
+  }
+  GST_context = GNUNET_new (struct Context);
   GST_context->client = client;
-  GST_context->host_id = ntohl(msg->host_id);
-  GST_context->master_ip = GNUNET_strdup(controller_hostname);
-  LOG_DEBUG("Our IP: %s\n",
-            GST_context->master_ip);
+  GST_context->host_id = ntohl (msg->host_id);
+  GST_context->master_ip = GNUNET_strdup (controller_hostname);
+  LOG_DEBUG ("Our IP: %s\n",
+             GST_context->master_ip);
   GST_context->system
-    = GNUNET_TESTING_system_create("testbed",
-                                   GST_context->master_ip,
-                                   hostname,
-                                   ss);
+    = GNUNET_TESTING_system_create ("testbed",
+                                    GST_context->master_ip,
+                                    hostname,
+                                    ss);
   if (NULL != ss)
+  {
+    for (cnt = 0; NULL != ss[cnt].service; cnt++)
     {
-      for (cnt = 0; NULL != ss[cnt].service; cnt++)
-        {
-          ss_str = (char *)ss[cnt].service;
-          GNUNET_free(ss_str);
-        }
-      GNUNET_free(ss);
-      ss = NULL;
+      ss_str = (char *) ss[cnt].service;
+      GNUNET_free (ss_str);
     }
+    GNUNET_free (ss);
+    ss = NULL;
+  }
   host =
-    GNUNET_TESTBED_host_create_with_id(GST_context->host_id,
-                                       GST_context->master_ip,
-                                       NULL,
-                                       GST_config,
-                                       0);
-  host_list_add(host);
-  LOG_DEBUG("Created master context with host ID: %u\n",
-            GST_context->host_id);
-  GNUNET_SERVICE_client_continue(client);
+    GNUNET_TESTBED_host_create_with_id (GST_context->host_id,
+                                        GST_context->master_ip,
+                                        NULL,
+                                        GST_config,
+                                        0);
+  host_list_add (host);
+  LOG_DEBUG ("Created master context with host ID: %u\n",
+             GST_context->host_id);
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -484,29 +484,30 @@ handle_init(void *cls,
  * @return #GNUNET_OK if @a message is well-formed
  */
 static int
-check_add_host(void *cls,
-               const struct GNUNET_TESTBED_AddHostMessage *msg)
+check_add_host (void *cls,
+                const struct GNUNET_TESTBED_AddHostMessage *msg)
 {
   uint16_t username_length;
   uint16_t hostname_length;
   uint16_t msize;
 
-  msize = ntohs(msg->header.size) - sizeof(struct GNUNET_TESTBED_AddHostMessage);
-  username_length = ntohs(msg->username_length);
-  hostname_length = ntohs(msg->hostname_length);
+  msize = ntohs (msg->header.size) - sizeof(struct
+                                            GNUNET_TESTBED_AddHostMessage);
+  username_length = ntohs (msg->username_length);
+  hostname_length = ntohs (msg->hostname_length);
   /* msg must contain hostname */
   if ((msize <= username_length) ||
       (0 == hostname_length))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   /* msg must contain configuration */
   if (msize <= username_length + hostname_length)
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -518,8 +519,8 @@ check_add_host(void *cls,
  * @param msg the actual message
  */
 static void
-handle_add_host(void *cls,
-                const struct GNUNET_TESTBED_AddHostMessage *msg)
+handle_add_host (void *cls,
+                 const struct GNUNET_TESTBED_AddHostMessage *msg)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   struct GNUNET_TESTBED_Host *host;
@@ -534,77 +535,77 @@ handle_add_host(void *cls,
   uint16_t hostname_length;
   struct GNUNET_MQ_Envelope *env;
 
-  username_length = ntohs(msg->username_length);
-  hostname_length = ntohs(msg->hostname_length);
+  username_length = ntohs (msg->username_length);
+  hostname_length = ntohs (msg->hostname_length);
   username = NULL;
   hostname = NULL;
   ptr = &msg[1];
   if (0 != username_length)
-    {
-      username = GNUNET_malloc(username_length + 1);
-      GNUNET_strlcpy(username, ptr, username_length + 1);
-      ptr += username_length;
-    }
-  hostname = GNUNET_malloc(hostname_length + 1);
-  GNUNET_strlcpy(hostname, ptr, hostname_length + 1);
-  if (NULL == (host_cfg = GNUNET_TESTBED_extract_config_(&msg->header)))
-    {
-      GNUNET_free_non_null(username);
-      GNUNET_free_non_null(hostname);
-      GNUNET_break_op(0);
-      GNUNET_SERVICE_client_drop(client);
-      return;
-    }
-  host_id = ntohl(msg->host_id);
-  LOG_DEBUG("Received ADDHOST %u message\n", host_id);
-  LOG_DEBUG("-------host id: %u\n", host_id);
-  LOG_DEBUG("-------hostname: %s\n", hostname);
+  {
+    username = GNUNET_malloc (username_length + 1);
+    GNUNET_strlcpy (username, ptr, username_length + 1);
+    ptr += username_length;
+  }
+  hostname = GNUNET_malloc (hostname_length + 1);
+  GNUNET_strlcpy (hostname, ptr, hostname_length + 1);
+  if (NULL == (host_cfg = GNUNET_TESTBED_extract_config_ (&msg->header)))
+  {
+    GNUNET_free_non_null (username);
+    GNUNET_free_non_null (hostname);
+    GNUNET_break_op (0);
+    GNUNET_SERVICE_client_drop (client);
+    return;
+  }
+  host_id = ntohl (msg->host_id);
+  LOG_DEBUG ("Received ADDHOST %u message\n", host_id);
+  LOG_DEBUG ("-------host id: %u\n", host_id);
+  LOG_DEBUG ("-------hostname: %s\n", hostname);
   if (NULL != username)
-    LOG_DEBUG("-------username: %s\n", username);
+    LOG_DEBUG ("-------username: %s\n", username);
   else
-    LOG_DEBUG("-------username: <not given>\n");
-  LOG_DEBUG("-------ssh port: %u\n", ntohs(msg->ssh_port));
-  host = GNUNET_TESTBED_host_create_with_id(host_id,
-                                            hostname,
-                                            username,
-                                            host_cfg,
-                                            ntohs(msg->ssh_port));
-  GNUNET_free_non_null(username);
-  GNUNET_free(hostname);
-  GNUNET_CONFIGURATION_destroy(host_cfg);
+    LOG_DEBUG ("-------username: <not given>\n");
+  LOG_DEBUG ("-------ssh port: %u\n", ntohs (msg->ssh_port));
+  host = GNUNET_TESTBED_host_create_with_id (host_id,
+                                             hostname,
+                                             username,
+                                             host_cfg,
+                                             ntohs (msg->ssh_port));
+  GNUNET_free_non_null (username);
+  GNUNET_free (hostname);
+  GNUNET_CONFIGURATION_destroy (host_cfg);
   if (NULL == host)
-    {
-      GNUNET_break_op(0);
-      GNUNET_SERVICE_client_drop(client);
-      return;
-    }
-  if (GNUNET_OK != host_list_add(host))
-    {
-      /* We are unable to add a host */
-      emsg = "A host exists with given host-id";
-      LOG_DEBUG("%s: %u",
-                emsg,
-                host_id);
-      GNUNET_TESTBED_host_destroy(host);
-      env = GNUNET_MQ_msg_extra(reply,
-                                strlen(emsg) + 1,
-                                GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS);
-      GNUNET_memcpy(&reply[1],
-                    emsg,
-                    strlen(emsg) + 1);
-    }
+  {
+    GNUNET_break_op (0);
+    GNUNET_SERVICE_client_drop (client);
+    return;
+  }
+  if (GNUNET_OK != host_list_add (host))
+  {
+    /* We are unable to add a host */
+    emsg = "A host exists with given host-id";
+    LOG_DEBUG ("%s: %u",
+               emsg,
+               host_id);
+    GNUNET_TESTBED_host_destroy (host);
+    env = GNUNET_MQ_msg_extra (reply,
+                               strlen (emsg) + 1,
+                               GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS);
+    GNUNET_memcpy (&reply[1],
+                   emsg,
+                   strlen (emsg) + 1);
+  }
   else
-    {
-      LOG_DEBUG("Added host %u at %u\n",
-                host_id,
-                GST_context->host_id);
-      env = GNUNET_MQ_msg(reply,
-                          GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS);
-    }
-  reply->host_id = htonl(host_id);
-  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client),
-                 env);
-  GNUNET_SERVICE_client_continue(client);
+  {
+    LOG_DEBUG ("Added host %u at %u\n",
+               host_id,
+               GST_context->host_id);
+    env = GNUNET_MQ_msg (reply,
+                         GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS);
+  }
+  reply->host_id = htonl (host_id);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                  env);
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -615,8 +616,9 @@ handle_add_host(void *cls,
  * @param msg the actual message
  */
 static void
-handle_slave_get_config(void *cls,
-                        const struct GNUNET_TESTBED_SlaveGetConfigurationMessage *msg)
+handle_slave_get_config (void *cls,
+                         const struct
+                         GNUNET_TESTBED_SlaveGetConfigurationMessage *msg)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   struct Slave *slave;
@@ -630,42 +632,45 @@ handle_slave_get_config(void *cls,
   uint64_t op_id;
   uint32_t slave_id;
 
-  slave_id = ntohl(msg->slave_id);
-  op_id = GNUNET_ntohll(msg->operation_id);
+  slave_id = ntohl (msg->slave_id);
+  op_id = GNUNET_ntohll (msg->operation_id);
   if ((GST_slave_list_size <= slave_id) ||
       (NULL == GST_slave_list[slave_id]))
-    {
-      /* FIXME: Add forwardings for this type of message here.. */
-      GST_send_operation_fail_msg(client,
-                                  op_id,
-                                  "Slave not found");
-      GNUNET_SERVICE_client_continue(client);
-      return;
-    }
+  {
+    /* FIXME: Add forwardings for this type of message here.. */
+    GST_send_operation_fail_msg (client,
+                                 op_id,
+                                 "Slave not found");
+    GNUNET_SERVICE_client_continue (client);
+    return;
+  }
   slave = GST_slave_list[slave_id];
-  GNUNET_assert(NULL != (cfg = GNUNET_TESTBED_host_get_cfg_(GST_host_list[slave->host_id])));
-  config = GNUNET_CONFIGURATION_serialize(cfg,
-                                          &config_size);
+  GNUNET_assert (NULL != (cfg = GNUNET_TESTBED_host_get_cfg_ (
+                            GST_host_list[slave->host_id])));
+  config = GNUNET_CONFIGURATION_serialize (cfg,
+                                           &config_size);
   /* FIXME: maybe we want to transmit the delta to the default here? */
-  xconfig_size = GNUNET_TESTBED_compress_config_(config,
-                                                 config_size,
-                                                 &xconfig);
-  GNUNET_free(config);
-  GNUNET_assert(xconfig_size + sizeof(struct GNUNET_TESTBED_SlaveConfiguration) <= UINT16_MAX);
-  GNUNET_assert(xconfig_size <= UINT16_MAX);
-  env = GNUNET_MQ_msg_extra(reply,
-                            xconfig_size,
-                            GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION);
+  xconfig_size = GNUNET_TESTBED_compress_config_ (config,
+                                                  config_size,
+                                                  &xconfig);
+  GNUNET_free (config);
+  GNUNET_assert (xconfig_size + sizeof(struct
+                                       GNUNET_TESTBED_SlaveConfiguration) <=
+                 UINT16_MAX);
+  GNUNET_assert (xconfig_size <= UINT16_MAX);
+  env = GNUNET_MQ_msg_extra (reply,
+                             xconfig_size,
+                             GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION);
   reply->slave_id = msg->slave_id;
   reply->operation_id = msg->operation_id;
-  reply->config_size = htons((uint16_t)config_size);
-  GNUNET_memcpy(&reply[1],
-                xconfig,
-                xconfig_size);
-  GNUNET_free(xconfig);
-  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client),
-                 env);
-  GNUNET_SERVICE_client_continue(client);
+  reply->config_size = htons ((uint16_t) config_size);
+  GNUNET_memcpy (&reply[1],
+                 xconfig,
+                 xconfig_size);
+  GNUNET_free (xconfig);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
+                  env);
+  GNUNET_SERVICE_client_continue (client);
 }
 
 
@@ -673,52 +678,52 @@ handle_slave_get_config(void *cls,
  * Clears the forwarded operations queue
  */
 void
-GST_clear_fopcq()
+GST_clear_fopcq ()
 {
   struct ForwardedOperationContext *fopc;
 
   while (NULL != (fopc = fopcq_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (fopcq_head,
+                                 fopcq_tail,
+                                 fopc);
+    GNUNET_TESTBED_forward_operation_msg_cancel_ (fopc->opc);
+    if (NULL != fopc->timeout_task)
+      GNUNET_SCHEDULER_cancel (fopc->timeout_task);
+    switch (fopc->type)
     {
-      GNUNET_CONTAINER_DLL_remove(fopcq_head,
-                                  fopcq_tail,
-                                  fopc);
-      GNUNET_TESTBED_forward_operation_msg_cancel_(fopc->opc);
-      if (NULL != fopc->timeout_task)
-        GNUNET_SCHEDULER_cancel(fopc->timeout_task);
-      switch (fopc->type)
-        {
-        case OP_PEER_CREATE:
-          GNUNET_free(fopc->cls);
-          break;
-
-        case OP_SHUTDOWN_PEERS:
-        {
-          struct HandlerContext_ShutdownPeers *hc = fopc->cls;
-
-          GNUNET_assert(0 < hc->nslaves);
-          hc->nslaves--;
-          if (0 == hc->nslaves)
-            GNUNET_free(hc);
-        }
-        break;
-
-        case OP_PEER_START:
-        case OP_PEER_STOP:
-        case OP_PEER_DESTROY:
-        case OP_PEER_INFO:
-        case OP_OVERLAY_CONNECT:
-        case OP_LINK_CONTROLLERS:
-        case OP_GET_SLAVE_CONFIG:
-        case OP_MANAGE_SERVICE:
-        case OP_PEER_RECONFIGURE:
-          break;
-
-        case OP_FORWARDED:
-          GNUNET_assert(0);
-        }
-      ;
-      GNUNET_free(fopc);
+    case OP_PEER_CREATE:
+      GNUNET_free (fopc->cls);
+      break;
+
+    case OP_SHUTDOWN_PEERS:
+      {
+        struct HandlerContext_ShutdownPeers *hc = fopc->cls;
+
+        GNUNET_assert (0 < hc->nslaves);
+        hc->nslaves--;
+        if (0 == hc->nslaves)
+          GNUNET_free (hc);
+      }
+      break;
+
+    case OP_PEER_START:
+    case OP_PEER_STOP:
+    case OP_PEER_DESTROY:
+    case OP_PEER_INFO:
+    case OP_OVERLAY_CONNECT:
+    case OP_LINK_CONTROLLERS:
+    case OP_GET_SLAVE_CONFIG:
+    case OP_MANAGE_SERVICE:
+    case OP_PEER_RECONFIGURE:
+      break;
+
+    case OP_FORWARDED:
+      GNUNET_assert (0);
     }
+    ;
+    GNUNET_free (fopc);
+  }
 }
 
 
@@ -728,49 +733,49 @@ GST_clear_fopcq()
  * @param cls NULL
  */
 static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
 {
   uint32_t id;
 
-  LOG_DEBUG("Shutting down testbed service\n");
+  LOG_DEBUG ("Shutting down testbed service\n");
   /* cleanup any remaining forwarded operations */
-  GST_clear_fopcq();
-  GST_free_lcf();
-  GST_free_mctxq();
-  GST_free_occq();
-  GST_free_roccq();
-  GST_free_nccq();
-  GST_neighbour_list_clean();
-  GST_free_prcq();
+  GST_clear_fopcq ();
+  GST_free_lcf ();
+  GST_free_mctxq ();
+  GST_free_occq ();
+  GST_free_roccq ();
+  GST_free_nccq ();
+  GST_neighbour_list_clean ();
+  GST_free_prcq ();
   /* Clear peer list */
-  GST_destroy_peers();
+  GST_destroy_peers ();
   /* Clear route list */
-  GST_route_list_clear();
+  GST_route_list_clear ();
   /* Clear GST_slave_list */
-  GST_slave_list_clear();
+  GST_slave_list_clear ();
   /* Clear host list */
   for (id = 0; id < GST_host_list_size; id++)
     if (NULL != GST_host_list[id])
-      GNUNET_TESTBED_host_destroy(GST_host_list[id]);
-  GNUNET_free_non_null(GST_host_list);
+      GNUNET_TESTBED_host_destroy (GST_host_list[id]);
+  GNUNET_free_non_null (GST_host_list);
   if (NULL != GST_context)
-    {
-      GNUNET_free_non_null(GST_context->master_ip);
-      if (NULL != GST_context->system)
-        GNUNET_TESTING_system_destroy(GST_context->system,
-                                      GNUNET_YES);
-      GNUNET_free(GST_context);
-      GST_context = NULL;
-    }
-  GNUNET_free_non_null(hostname);
+  {
+    GNUNET_free_non_null (GST_context->master_ip);
+    if (NULL != GST_context->system)
+      GNUNET_TESTING_system_destroy (GST_context->system,
+                                     GNUNET_YES);
+    GNUNET_free (GST_context);
+    GST_context = NULL;
+  }
+  GNUNET_free_non_null (hostname);
   /* Free hello cache */
-  GST_cache_clear();
-  GST_connection_pool_destroy();
-  GNUNET_TESTBED_operation_queue_destroy_(GST_opq_openfds);
+  GST_cache_clear ();
+  GST_connection_pool_destroy ();
+  GNUNET_TESTBED_operation_queue_destroy_ (GST_opq_openfds);
   GST_opq_openfds = NULL;
-  GST_stats_destroy();
-  GST_barriers_destroy();
-  GNUNET_CONFIGURATION_destroy(GST_config);
+  GST_stats_destroy ();
+  GST_barriers_destroy ();
+  GNUNET_CONFIGURATION_destroy (GST_config);
 }
 
 
@@ -783,9 +788,9 @@ shutdown_task(void *cls)
  * @return @a client
  */
 static void *
-client_connect_cb(void *cls,
-                  struct GNUNET_SERVICE_Client *client,
-                  struct GNUNET_MQ_Handle *mq)
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *client,
+                   struct GNUNET_MQ_Handle *mq)
 {
   return client;
 }
@@ -799,41 +804,41 @@ client_connect_cb(void *cls,
  * @param app_ctx should match @a client
  */
 static void
-client_disconnect_cb(void *cls,
-                     struct GNUNET_SERVICE_Client *client,
-                     void *app_ctx)
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *app_ctx)
 {
   struct ForwardedOperationContext *fopc;
   struct ForwardedOperationContext *fopcn;
 
-  GNUNET_assert(client == app_ctx);
-  GST_notify_client_disconnect_oc(client);
-  GST_link_notify_disconnect(client);
-  GST_notify_client_disconnect_peers(client);
+  GNUNET_assert (client == app_ctx);
+  GST_notify_client_disconnect_oc (client);
+  GST_link_notify_disconnect (client);
+  GST_notify_client_disconnect_peers (client);
   for (fopc = fopcq_head; NULL != fopc; fopc = fopcn)
+  {
+    fopcn = fopc->next;
+    if (fopc->client == client)
     {
-      fopcn = fopc->next;
-      if (fopc->client == client)
-        {
-          /* handle as if it were a timeout */
-          GNUNET_SCHEDULER_cancel(fopc->timeout_task);
-          GST_forwarded_operation_timeout(fopc);
-        }
+      /* handle as if it were a timeout */
+      GNUNET_SCHEDULER_cancel (fopc->timeout_task);
+      GST_forwarded_operation_timeout (fopc);
     }
+  }
   if (NULL == GST_context)
     return;
   if (client == GST_context->client)
-    {
-      LOG(GNUNET_ERROR_TYPE_DEBUG,
-          "Master client disconnected\n");
-      GST_context->client = NULL;
-      /* should not be needed as we're terminated by failure to read
-       * from stdin, but if stdin fails for some reason, this shouldn't
-       * hurt for now --- might need to revise this later if we ever
-       * decide that master connections might be temporarily down
-       * for some reason */
-      //GNUNET_SCHEDULER_shutdown ();
-    }
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Master client disconnected\n");
+    GST_context->client = NULL;
+    /* should not be needed as we're terminated by failure to read
+     * from stdin, but if stdin fails for some reason, this shouldn't
+     * hurt for now --- might need to revise this later if we ever
+     * decide that master connections might be temporarily down
+     * for some reason */
+    // GNUNET_SCHEDULER_shutdown ();
+  }
 }
 
 
@@ -845,54 +850,55 @@ client_disconnect_cb(void *cls,
  * @param service the initialized server
  */
 static void
-testbed_run(void *cls,
-            const struct GNUNET_CONFIGURATION_Handle *cfg,
-            struct GNUNET_SERVICE_Handle *service)
+testbed_run (void *cls,
+             const struct GNUNET_CONFIGURATION_Handle *cfg,
+             struct GNUNET_SERVICE_Handle *service)
 {
   char *logfile;
   unsigned long long num;
 
-  LOG_DEBUG("Starting testbed\n");
+  LOG_DEBUG ("Starting testbed\n");
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_get_value_filename(cfg, "TESTBED", "LOG_FILE",
-                                              &logfile))
-    {
-      GNUNET_break(GNUNET_OK ==
-                   GNUNET_log_setup("testbed",
+      GNUNET_CONFIGURATION_get_value_filename (cfg, "TESTBED", "LOG_FILE",
+                                               &logfile))
+  {
+    GNUNET_break (GNUNET_OK ==
+                  GNUNET_log_setup ("testbed",
                                     "DEBUG",
                                     logfile));
-      GNUNET_free(logfile);
-    }
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                      "testbed",
-                                                      "CACHE_SIZE",
-                                                      &num));
-  GST_cache_init((unsigned int)num);
-  GST_connection_pool_init((unsigned int)num);
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONFIGURATION_get_value_number(cfg,
-                                                      "testbed",
-                                                      "MAX_OPEN_FDS",
-                                                      &num));
-  GST_opq_openfds = GNUNET_TESTBED_operation_queue_create_(OPERATION_QUEUE_TYPE_FIXED,
-                                                           (unsigned int)num);
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONFIGURATION_get_value_time(cfg,
-                                                    "testbed",
-                                                    "OPERATION_TIMEOUT",
-                                                    &GST_timeout));
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONFIGURATION_get_value_string(cfg,
+    GNUNET_free (logfile);
+  }
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                        "testbed",
+                                                        "CACHE_SIZE",
+                                                        &num));
+  GST_cache_init ((unsigned int) num);
+  GST_connection_pool_init ((unsigned int) num);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                        "testbed",
+                                                        "MAX_OPEN_FDS",
+                                                        &num));
+  GST_opq_openfds = GNUNET_TESTBED_operation_queue_create_ (
+    OPERATION_QUEUE_TYPE_FIXED,
+    (unsigned int) num);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_get_value_time (cfg,
                                                       "testbed",
-                                                      "HOSTNAME",
-                                                      &hostname));
-  GST_config = GNUNET_CONFIGURATION_dup(cfg);
-  GNUNET_SCHEDULER_add_shutdown(&shutdown_task,
-                                NULL);
-  LOG_DEBUG("Testbed startup complete\n");
-  GST_stats_init(GST_config);
-  GST_barriers_init(GST_config);
+                                                      "OPERATION_TIMEOUT",
+                                                      &GST_timeout));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                        "testbed",
+                                                        "HOSTNAME",
+                                                        &hostname));
+  GST_config = GNUNET_CONFIGURATION_dup (cfg);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
+                                 NULL);
+  LOG_DEBUG ("Testbed startup complete\n");
+  GST_stats_init (GST_config);
+  GST_barriers_init (GST_config);
 }
 
 
@@ -906,75 +912,75 @@ GNUNET_SERVICE_MAIN
   &client_connect_cb,
   &client_disconnect_cb,
   NULL,
-  GNUNET_MQ_hd_var_size(init,
-                        GNUNET_MESSAGE_TYPE_TESTBED_INIT,
-                        struct GNUNET_TESTBED_InitMessage,
-                        NULL),
-  GNUNET_MQ_hd_var_size(add_host,
-                        GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST,
-                        struct GNUNET_TESTBED_AddHostMessage,
-                        NULL),
-  GNUNET_MQ_hd_fixed_size(slave_get_config,
-                          GNUNET_MESSAGE_TYPE_TESTBED_GET_SLAVE_CONFIGURATION,
-                          struct GNUNET_TESTBED_SlaveGetConfigurationMessage,
-                          NULL),
-  GNUNET_MQ_hd_fixed_size(link_controllers,
-                          GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS,
-                          struct GNUNET_TESTBED_ControllerLinkRequest,
-                          NULL),
-  GNUNET_MQ_hd_var_size(remote_overlay_connect,
-                        GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT,
-                        struct GNUNET_TESTBED_RemoteOverlayConnectMessage,
-                        NULL),
-  GNUNET_MQ_hd_fixed_size(overlay_connect,
-                          GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT,
-                          struct GNUNET_TESTBED_OverlayConnectMessage,
-                          NULL),
-  GNUNET_MQ_hd_var_size(peer_create,
-                        GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER,
-                        struct GNUNET_TESTBED_PeerCreateMessage,
-                        NULL),
-  GNUNET_MQ_hd_fixed_size(peer_destroy,
-                          GNUNET_MESSAGE_TYPE_TESTBED_DESTROY_PEER,
-                          struct GNUNET_TESTBED_PeerDestroyMessage,
-                          NULL),
-  GNUNET_MQ_hd_fixed_size(peer_start,
-                          GNUNET_MESSAGE_TYPE_TESTBED_START_PEER,
-                          struct GNUNET_TESTBED_PeerStartMessage,
-                          NULL),
-  GNUNET_MQ_hd_fixed_size(peer_stop,
-                          GNUNET_MESSAGE_TYPE_TESTBED_STOP_PEER,
-                          struct GNUNET_TESTBED_PeerStopMessage,
-                          NULL),
-  GNUNET_MQ_hd_fixed_size(peer_get_config,
-                          GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_INFORMATION,
-                          struct GNUNET_TESTBED_PeerGetConfigurationMessage,
-                          NULL),
-  GNUNET_MQ_hd_var_size(manage_peer_service,
-                        GNUNET_MESSAGE_TYPE_TESTBED_MANAGE_PEER_SERVICE,
-                        struct GNUNET_TESTBED_ManagePeerServiceMessage,
-                        NULL),
-  GNUNET_MQ_hd_fixed_size(shutdown_peers,
-                          GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS,
-                          struct GNUNET_TESTBED_ShutdownPeersMessage,
-                          NULL),
-  GNUNET_MQ_hd_var_size(peer_reconfigure,
-                        GNUNET_MESSAGE_TYPE_TESTBED_RECONFIGURE_PEER,
-                        struct GNUNET_TESTBED_PeerReconfigureMessage,
-                        NULL),
-  GNUNET_MQ_hd_var_size(barrier_init,
-                        GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT,
-                        struct GNUNET_TESTBED_BarrierInit,
-                        NULL),
-  GNUNET_MQ_hd_var_size(barrier_cancel,
-                        GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL,
-                        struct GNUNET_TESTBED_BarrierCancel,
-                        NULL),
-  GNUNET_MQ_hd_var_size(barrier_status,
-                        GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS,
-                        struct GNUNET_TESTBED_BarrierStatusMsg,
-                        NULL),
-  GNUNET_MQ_handler_end());
+  GNUNET_MQ_hd_var_size (init,
+                         GNUNET_MESSAGE_TYPE_TESTBED_INIT,
+                         struct GNUNET_TESTBED_InitMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (add_host,
+                         GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST,
+                         struct GNUNET_TESTBED_AddHostMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (slave_get_config,
+                           GNUNET_MESSAGE_TYPE_TESTBED_GET_SLAVE_CONFIGURATION,
+                           struct GNUNET_TESTBED_SlaveGetConfigurationMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (link_controllers,
+                           GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS,
+                           struct GNUNET_TESTBED_ControllerLinkRequest,
+                           NULL),
+  GNUNET_MQ_hd_var_size (remote_overlay_connect,
+                         GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT,
+                         struct GNUNET_TESTBED_RemoteOverlayConnectMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (overlay_connect,
+                           GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT,
+                           struct GNUNET_TESTBED_OverlayConnectMessage,
+                           NULL),
+  GNUNET_MQ_hd_var_size (peer_create,
+                         GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER,
+                         struct GNUNET_TESTBED_PeerCreateMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (peer_destroy,
+                           GNUNET_MESSAGE_TYPE_TESTBED_DESTROY_PEER,
+                           struct GNUNET_TESTBED_PeerDestroyMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (peer_start,
+                           GNUNET_MESSAGE_TYPE_TESTBED_START_PEER,
+                           struct GNUNET_TESTBED_PeerStartMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (peer_stop,
+                           GNUNET_MESSAGE_TYPE_TESTBED_STOP_PEER,
+                           struct GNUNET_TESTBED_PeerStopMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (peer_get_config,
+                           GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_INFORMATION,
+                           struct GNUNET_TESTBED_PeerGetConfigurationMessage,
+                           NULL),
+  GNUNET_MQ_hd_var_size (manage_peer_service,
+                         GNUNET_MESSAGE_TYPE_TESTBED_MANAGE_PEER_SERVICE,
+                         struct GNUNET_TESTBED_ManagePeerServiceMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (shutdown_peers,
+                           GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS,
+                           struct GNUNET_TESTBED_ShutdownPeersMessage,
+                           NULL),
+  GNUNET_MQ_hd_var_size (peer_reconfigure,
+                         GNUNET_MESSAGE_TYPE_TESTBED_RECONFIGURE_PEER,
+                         struct GNUNET_TESTBED_PeerReconfigureMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (barrier_init,
+                         GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT,
+                         struct GNUNET_TESTBED_BarrierInit,
+                         NULL),
+  GNUNET_MQ_hd_var_size (barrier_cancel,
+                         GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL,
+                         struct GNUNET_TESTBED_BarrierCancel,
+                         NULL),
+  GNUNET_MQ_hd_var_size (barrier_status,
+                         GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS,
+                         struct GNUNET_TESTBED_BarrierStatusMsg,
+                         NULL),
+  GNUNET_MQ_handler_end ());
 
 
 /* end of gnunet-service-testbed.c */