gnunet-service-testbed.c

Go to the documentation of this file.

/*
  This file is part of GNUnet.
  Copyright (C) 2008--2013, 2016 GNUnet e.V.

  GNUnet is free software: you can redistribute it and/or modify it
  under the terms of the GNU Affero General Public License as published
  by the Free Software Foundation, either version 3 of the License,
  or (at your option) any later version.

  GNUnet is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Affero General Public License for more details.
 
  You should have received a copy of the GNU Affero General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.

     SPDX-License-Identifier: AGPL3.0-or-later
*/

#include "gnunet-service-testbed.h"
#include "gnunet-service-testbed_barriers.h"
#include "gnunet-service-testbed_connectionpool.h"

/***********/
/* Globals */
/***********/

struct GNUNET_CONFIGURATION_Handle *GST_config;

struct Context *GST_context;

struct GNUNET_TESTBED_Host **GST_host_list;

struct ForwardedOperationContext *fopcq_head;

struct ForwardedOperationContext *fopcq_tail;

struct OperationQueue *GST_opq_openfds;

const struct GNUNET_TIME_Relative GST_timeout;

unsigned int GST_host_list_size;

unsigned int GST_peer_list_size;


/***********************************/
/* Local definitions and variables */
/***********************************/

static char *hostname;


static int
host_list_add (struct GNUNET_TESTBED_Host *host)
{
  uint32_t host_id;

  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);
  if (NULL != GST_host_list[host_id])
  {
    LOG_DEBUG ("A host with id: %u already exists\n", host_id);
    return GNUNET_SYSERR;
  }
  GST_host_list[host_id] = host;
  return GNUNET_OK;
}


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


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


static void
hr_completion (void *cls,
               const char *emsg);


static void
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]));
  slave->rhandle
    = GNUNET_TESTBED_register_host (slave->controller,
                                    hr->host,
                                    hr_completion,
                                    slave);
}


static void
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);
  if (NULL != hr->cb)
    hr->cb (hr->cb_cls,
            emsg);
  GNUNET_free (hr);
  if (NULL != slave->hr_dll_head)
    register_next_host (slave);
}


void
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);
  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);
  if (GNUNET_YES == call_register)
    register_next_host (slave);
}


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


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


static struct GNUNET_TESTING_SharedService *
parse_shared_services (char *ss_str,
                       struct GNUNET_CONFIGURATION_Handle *cfg)
{
  struct GNUNET_TESTING_SharedService ss;
  struct GNUNET_TESTING_SharedService *slist;
  char service[256];
  char *arg;
  unsigned int n;
#define GROW_SS                                 \
  do {                                          \
    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)
  {
    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;
  }
  if (NULL != slist)
  {
    /* Add trailing NULL block */
    (void) memset (&ss,
                   0,
                   sizeof (struct GNUNET_TESTING_SharedService));
    GROW_SS;
  }
  return slist;
#undef GROW_SS
}


static int
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];
  if ('\0' != controller_hostname[msize - 1])
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}


static void
handle_init (void *cls,
             const struct GNUNET_TESTBED_InitMessage *msg)
{
  struct GNUNET_SERVICE_Client *client = cls;
  struct GNUNET_TESTBED_Host *host;
  const char *controller_hostname;
  char *ss_str;
  struct GNUNET_TESTING_SharedService *ss;
  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];
  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);
  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->system
    = GNUNET_TESTING_system_create ("testbed",
                                    GST_context->master_ip,
                                    hostname,
                                    ss);
  if (NULL != ss)
  {
    for (cnt = 0; NULL != ss[cnt].service; cnt++)
    {
      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);
}


static int
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);
  /* msg must contain hostname */
  if ( (msize <= username_length) ||
       (0 == hostname_length) )
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  /* msg must contain configuration */
  if (msize <= username_length + hostname_length)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}


static void
handle_add_host (void *cls,
                 const struct GNUNET_TESTBED_AddHostMessage *msg)
{
  struct GNUNET_SERVICE_Client *client = cls;
  struct GNUNET_TESTBED_Host *host;
  struct GNUNET_TESTBED_HostConfirmedMessage *reply;
  struct GNUNET_CONFIGURATION_Handle *host_cfg;
  char *username;
  char *hostname;
  char *emsg;
  const void *ptr;
  uint32_t host_id;
  uint16_t username_length;
  uint16_t hostname_length;
  struct GNUNET_MQ_Envelope *env;

  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);
  if (NULL != 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);
  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);
  }
  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);
}


static void
handle_slave_get_config (void *cls,
                         const struct GNUNET_TESTBED_SlaveGetConfigurationMessage *msg)
{
  struct GNUNET_SERVICE_Client *client = cls;
  struct Slave *slave;
  struct GNUNET_TESTBED_SlaveConfiguration *reply;
  const struct GNUNET_CONFIGURATION_Handle *cfg;
  struct GNUNET_MQ_Envelope *env;
  char *config;
  char *xconfig;
  size_t config_size;
  size_t xconfig_size;
  uint64_t op_id;
  uint32_t slave_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;
  }
  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);
  /* 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);
  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);
}


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


static void
shutdown_task (void *cls)
{
  uint32_t id;

  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 ();
  /* Clear peer list */
  GST_destroy_peers ();
  /* Clear route list */
  GST_route_list_clear ();
  /* Clear GST_slave_list */
  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);
  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);
  /* Free hello cache */
  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);
}


static void *
client_connect_cb (void *cls,
                   struct GNUNET_SERVICE_Client *client,
                   struct GNUNET_MQ_Handle *mq)
{
  return client;
}


static void
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);
  for (fopc = fopcq_head; NULL != fopc; fopc = fopcn)
  {
    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);
    }
  }
  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 ();
  }
}


static void
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");
  if (GNUNET_OK ==
      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",
                                                      (struct GNUNET_TIME_Relative *)
                                                      &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);
}


GNUNET_SERVICE_MAIN
("testbed",
 GNUNET_SERVICE_OPTION_NONE,
 &testbed_run,
 &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 ());


/* end of gnunet-service-testbed.c */