gnunet-service-testbed.c File Reference

implementation of the TESTBED service More...

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

Include dependency graph for gnunet-service-testbed.c:

Go to the source code of this file.

Macros
#define	GROW_SS

Functions
static int	host_list_add (struct GNUNET_TESTBED_Host *host)
	Function to add a host to the current list of known hosts. More...
void	GST_send_operation_fail_msg (struct GNUNET_SERVICE_Client *client, uint64_t operation_id, const char *emsg)
	Send operation failure message to client. More...
void	GST_send_operation_success_msg (struct GNUNET_SERVICE_Client *client, uint64_t operation_id)
	Function to send generic operation success message to given client. More...
static void	hr_completion (void *cls, const char *emsg)
	Callback which will be called after a host registration succeeded or failed. More...
static void	register_next_host (struct Slave *slave)
	Attempts to register the next host in the host registration queue. More...
void	GST_queue_host_registration (struct Slave *slave, GNUNET_TESTBED_HostRegistrationCompletion cb, void *cb_cls, struct GNUNET_TESTBED_Host *host)
	Adds a host registration's request to a slave's registration queue. More...
void	GST_forwarded_operation_reply_relay (void *cls, const struct GNUNET_MessageHeader *msg)
	Callback to relay the reply msg of a forwarded operation back to the client. More...
void	GST_forwarded_operation_timeout (void *cls)
	Task to free resources when forwarded operation has been timed out. More...
static struct GNUNET_TESTING_SharedService *	parse_shared_services (char *ss_str, struct GNUNET_CONFIGURATION_Handle *cfg)
	Parse service sharing specification line. More...
static int	check_init (void *cls, const struct GNUNET_TESTBED_InitMessage *msg)
	Check GNUNET_MESSAGE_TYPE_TESTBED_INIT messages. More...
static void	handle_init (void *cls, const struct GNUNET_TESTBED_InitMessage *msg)
	Message handler for GNUNET_MESSAGE_TYPE_TESTBED_INIT messages. More...
static int	check_add_host (void *cls, const struct GNUNET_TESTBED_AddHostMessage *msg)
	Check #GNUNET_MESSAGE_TYPE_TESTBED_ADDHOST messages. More...
static void	handle_add_host (void *cls, const struct GNUNET_TESTBED_AddHostMessage *msg)
	Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_ADDHOST messages. More...
static void	handle_slave_get_config (void *cls, const struct GNUNET_TESTBED_SlaveGetConfigurationMessage *msg)
	Handler for #GNUNET_MESSAGE_TYPE_TESTBED_GETSLAVECONFIG messages. More...
void	GST_clear_fopcq ()
	Clears the forwarded operations queue. More...
static void	shutdown_task (void *cls)
	Task to clean up and shutdown nicely. More...
static void *	client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
	Callback for client connect. More...
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
	Callback for client disconnect. More...
static void	testbed_run (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_SERVICE_Handle *service)
	Testbed setup. More...
	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())
	Define "main" method using service macro. More...

Variables
struct GNUNET_CONFIGURATION_Handle *	GST_config
	Our configuration. More...
struct Context *	GST_context
	The master context; generated with the first INIT message. More...
struct GNUNET_TESTBED_Host **	GST_host_list
	Array of hosts. More...
struct ForwardedOperationContext *	fopcq_head
	DLL head for forwarded operation contexts. More...
struct ForwardedOperationContext *	fopcq_tail
	DLL tail for forwarded operation contexts. More...
struct OperationQueue *	GST_opq_openfds
	Operation queue for open file descriptors. More...
struct GNUNET_TIME_Relative	GST_timeout
	Timeout for operations which may take some time. More...
unsigned int	GST_host_list_size
	The size of the host list. More...
unsigned int	GST_peer_list_size
	The size of the peer list. More...
static char *	hostname
	Our hostname; we give this to all the peers we start. More...

Detailed Description

implementation of the TESTBED service

Author

Sree Harsha Totakura

Definition in file gnunet-service-testbed.c.

Macro Definition Documentation

GROW_SS

#define GROW_SS

Value:

  do {                                          \
    GNUNET_array_grow (slist, n, n + 1);                                  \
    GNUNET_memcpy (&slist[n - 1], &ss,                                  \
                   sizeof(struct GNUNET_TESTING_SharedService));       \
  } while (0)

Function Documentation

host_list_add()

static int host_list_add ( struct GNUNET_TESTBED_Host *  host )

static

Function to add a host to the current list of known hosts.

Parameters

host	the host to add

Returns

GNUNET_OK on success; GNUNET_SYSERR on failure due to host-id already in use

Definition at line 100 of file gnunet-service-testbed.c.

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

References GNUNET_OK, GNUNET_SYSERR, GNUNET_TESTBED_host_get_id_(), GST_array_grow_large_enough, GST_host_list, GST_host_list_size, and LOG_DEBUG.

Referenced by handle_add_host(), and handle_init().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_send_operation_fail_msg()

void GST_send_operation_fail_msg	(	struct GNUNET_SERVICE_Client *	client,
		uint64_t	operation_id,
		const char *	emsg
	)

Send operation failure message to client.

Parameters

client	the client to which the failure message has to be sent to
operation_id	the id of the failed operation
emsg	the error message; can be NULL

Definition at line 125 of file gnunet-service-testbed.c.

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

References env, GNUNET_htonll(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_SERVICE_client_get_mq(), GNUNET_TESTBED_ET_OPERATION_FINISHED, msg, and GNUNET_TESTBED_OperationFailureEventMessage::operation_id.

Referenced by GST_forwarded_operation_timeout(), handle_manage_peer_service(), handle_peer_create(), handle_peer_destroy(), handle_peer_get_config(), handle_peer_reconfigure(), handle_peer_start(), handle_peer_stop(), handle_slave_get_config(), prc_stop_cb(), service_manage_result_cb(), shutdown_peers_reply_cb(), and timeout_overlay_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_send_operation_success_msg()

void GST_send_operation_success_msg	(	struct GNUNET_SERVICE_Client *	client,
		uint64_t	operation_id
	)

Function to send generic operation success message to given client.

Parameters

client	the client to send the message to
operation_id	the id of the operation which was successful

Definition at line 154 of file gnunet-service-testbed.c.

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

References env, GNUNET_htonll(), GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_get_mq(), GNUNET_TESTBED_ET_OPERATION_FINISHED, msg, and GNUNET_TESTBED_GenericOperationSuccessEventMessage::operation_id.

Referenced by handle_peer_destroy(), handle_peer_reconfigure(), handle_shutdown_peers(), prc_stop_cb(), service_manage_result_cb(), and shutdown_peers_reply_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

hr_completion()

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

static

Callback which will be called after a host registration succeeded or failed.

Callback which will be called to after a host registration succeeded or failed.

Parameters

cls	the handle to the slave at which the registration is completed
emsg	the error message; NULL if host registration is successful

Definition at line 212 of file gnunet-service-testbed.c.

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

References HostRegistration::cb, HostRegistration::cb_cls, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_TESTBED_host_get_id_(), GST_host_list, HostRegistration::host, Slave::host_id, Slave::hr_dll_head, Slave::hr_dll_tail, LOG, register_next_host(), and Slave::rhandle.

Referenced by register_next_host().

Here is the call graph for this function:

Here is the caller graph for this function:

register_next_host()

static void register_next_host ( struct Slave *  slave )

static

Attempts to register the next host in the host registration queue.

Parameters

slave

the slave controller whose host registration queue is checked for host registrations

Definition at line 187 of file gnunet-service-testbed.c.

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

References Slave::controller, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_TESTBED_host_get_id_(), GNUNET_TESTBED_register_host(), GST_host_list, HostRegistration::host, Slave::host_id, hr_completion(), Slave::hr_dll_head, LOG, and Slave::rhandle.

Referenced by GST_queue_host_registration(), and hr_completion().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_queue_host_registration()

void GST_queue_host_registration	(	struct Slave *	slave,
		GNUNET_TESTBED_HostRegistrationCompletion	cb,
		void *	cb_cls,
		struct GNUNET_TESTBED_Host *	host
	)

Adds a host registration's request to a slave's registration queue.

Parameters

slave	the slave controller at which the given host has to be registered
cb	the host registration completion callback
cb_cls	the closure for the host registration completion callback
host	the host which has to be registered

Definition at line 247 of file gnunet-service-testbed.c.

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

References HostRegistration::cb, HostRegistration::cb_cls, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_NO, GNUNET_TESTBED_host_get_id_(), GNUNET_YES, GST_host_list, HostRegistration::host, Slave::host_id, Slave::hr_dll_head, Slave::hr_dll_tail, LOG, and register_next_host().

Referenced by lcf_proc_task(), and register_host().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_forwarded_operation_reply_relay()

void GST_forwarded_operation_reply_relay	(	void *	cls,
		const struct GNUNET_MessageHeader *	msg
	)

Callback to relay the reply msg of a forwarded operation back to the client.

Parameters

cls	ForwardedOperationContext
msg	the message to relay

Definition at line 279 of file gnunet-service-testbed.c.

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

References ForwardedOperationContext::client, ForwardedOperationContext::cls, env, fopcq_head, fopcq_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_msg_copy(), GNUNET_MQ_send(), GNUNET_SCHEDULER_cancel(), GNUNET_SERVICE_client_get_mq(), LOG_DEBUG, msg, GNUNET_MessageHeader::size, ForwardedOperationContext::timeout_task, and GNUNET_MessageHeader::type.

Referenced by forward_overlay_connect(), forwarded_overlay_connect_listener(), handle_manage_peer_service(), handle_peer_get_config(), handle_peer_reconfigure(), handle_peer_start(), handle_peer_stop(), peer_create_success_cb(), and peer_destroy_success_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_forwarded_operation_timeout()

void GST_forwarded_operation_timeout

(

void *

cls

)

Task to free resources when forwarded operation has been timed out.

Parameters

cls	the ForwardedOperationContext

Definition at line 300 of file gnunet-service-testbed.c.

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

References ForwardedOperationContext::client, ForwardedOperationContext::cls, fopcq_head, fopcq_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_TESTBED_forward_operation_msg_cancel_(), GST_send_operation_fail_msg(), LOG, ForwardedOperationContext::opc, ForwardedOperationContext::operation_id, and ForwardedOperationContext::timeout_task.

Referenced by client_disconnect_cb(), forward_overlay_connect(), forwarded_overlay_connect_timeout(), GST_notify_client_disconnect_oc(), GST_notify_client_disconnect_peers(), handle_manage_peer_service(), handle_peer_destroy(), handle_peer_get_config(), handle_peer_reconfigure(), handle_peer_start(), handle_peer_stop(), and peer_create_forward_timeout().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_shared_services()

static struct GNUNET_TESTING_SharedService* parse_shared_services ( char *  ss_str, struct GNUNET_CONFIGURATION_Handle *  cfg  )

static

Parse service sharing specification line.

Format is "[<service:share>] [<service:share>] ..."

Parameters

ss_str	the spec string to be parsed
cfg	the configuration to use for shared services

Returns

an array suitable to pass to GNUNET_TESTING_system_create(). NULL upon empty service sharing specification.

Definition at line 328 of file gnunet-service-testbed.c.

{
  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
}

References find_typedefs::arg, cfg, GNUNET_TESTING_SharedService::cfg, GNUNET_ERROR_TYPE_WARNING, GNUNET_strdup, GROW_SS, LOG, LOG_DEBUG, service, GNUNET_TESTING_SharedService::service, and GNUNET_TESTING_SharedService::share.

Referenced by handle_init().

Here is the caller graph for this function:

check_init()

static int check_init ( void *  cls, const struct GNUNET_TESTBED_InitMessage *  msg  )

static

Check GNUNET_MESSAGE_TYPE_TESTBED_INIT messages.

Parameters

cls	identification of the client
msg	the actual message

Returns

GNUNET_OK if message is well-formed

Definition at line 387 of file gnunet-service-testbed.c.

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

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, msg, and GNUNET_MessageHeader::size.

handle_init()

static void handle_init ( void *  cls, const struct GNUNET_TESTBED_InitMessage *  msg  )

static

Message handler for GNUNET_MESSAGE_TYPE_TESTBED_INIT messages.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 411 of file gnunet-service-testbed.c.

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

References Context::client, GNUNET_CONFIGURATION_get_value_string(), GNUNET_free, GNUNET_new, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_strdup, GNUNET_TESTBED_host_create_with_id(), GNUNET_TESTING_system_create(), GST_config, GST_context, Context::host_id, host_list_add(), hostname, LOG_DEBUG, Context::master_ip, msg, parse_shared_services(), service, GNUNET_TESTING_SharedService::service, and Context::system.

Here is the call graph for this function:

check_add_host()

static int check_add_host ( void *  cls, const struct GNUNET_TESTBED_AddHostMessage *  msg  )

static

Check #GNUNET_MESSAGE_TYPE_TESTBED_ADDHOST messages.

Parameters

cls	identification of the client
msg	the actual message

Returns

GNUNET_OK if message is well-formed

Definition at line 483 of file gnunet-service-testbed.c.

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

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, msg, and GNUNET_MessageHeader::size.

handle_add_host()

static void handle_add_host ( void *  cls, const struct GNUNET_TESTBED_AddHostMessage *  msg  )

static

Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_ADDHOST messages.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 518 of file gnunet-service-testbed.c.

{
  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 (username);
    GNUNET_free (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 (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);
}

References env, GNUNET_break_op, GNUNET_CONFIGURATION_destroy(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS, GNUNET_MQ_msg, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SERVICE_client_get_mq(), GNUNET_strlcpy(), GNUNET_TESTBED_extract_config_(), GNUNET_TESTBED_host_create_with_id(), GNUNET_TESTBED_host_destroy(), GST_context, Context::host_id, GNUNET_TESTBED_HostConfirmedMessage::host_id, host_list_add(), hostname, LOG_DEBUG, and msg.

Here is the call graph for this function:

handle_slave_get_config()

static void handle_slave_get_config ( void *  cls, const struct GNUNET_TESTBED_SlaveGetConfigurationMessage *  msg  )

static

Handler for #GNUNET_MESSAGE_TYPE_TESTBED_GETSLAVECONFIG messages.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 615 of file gnunet-service-testbed.c.

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

References cfg, config, GNUNET_TESTBED_SlaveConfiguration::config_size, env, GNUNET_assert, GNUNET_CONFIGURATION_serialize(), GNUNET_free, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_ntohll(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_get_mq(), GNUNET_TESTBED_compress_config_(), GNUNET_TESTBED_host_get_cfg_(), GST_host_list, GST_send_operation_fail_msg(), GST_slave_list, GST_slave_list_size, Slave::host_id, msg, GNUNET_TESTBED_SlaveConfiguration::operation_id, and GNUNET_TESTBED_SlaveConfiguration::slave_id.

Here is the call graph for this function:

GST_clear_fopcq()

void GST_clear_fopcq

(

void

)

Clears the forwarded operations queue.

Definition at line 677 of file gnunet-service-testbed.c.

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

References ForwardedOperationContext::cls, fopcq_head, fopcq_tail, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_TESTBED_forward_operation_msg_cancel_(), HandlerContext_ShutdownPeers::nslaves, OP_FORWARDED, OP_GET_SLAVE_CONFIG, OP_LINK_CONTROLLERS, OP_MANAGE_SERVICE, OP_OVERLAY_CONNECT, OP_PEER_CREATE, OP_PEER_DESTROY, OP_PEER_INFO, OP_PEER_RECONFIGURE, OP_PEER_START, OP_PEER_STOP, OP_SHUTDOWN_PEERS, ForwardedOperationContext::opc, ForwardedOperationContext::timeout_task, and ForwardedOperationContext::type.

Referenced by handle_shutdown_peers(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task to clean up and shutdown nicely.

Parameters

cls

NULL

Definition at line 732 of file gnunet-service-testbed.c.

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

References GNUNET_CONFIGURATION_destroy(), GNUNET_free, GNUNET_TESTBED_host_destroy(), GNUNET_TESTBED_operation_queue_destroy_(), GNUNET_TESTING_system_destroy(), GNUNET_YES, GST_barriers_destroy(), GST_cache_clear(), GST_clear_fopcq(), GST_config, GST_connection_pool_destroy(), GST_context, GST_destroy_peers(), GST_free_lcf(), GST_free_mctxq(), GST_free_nccq(), GST_free_occq(), GST_free_prcq(), GST_free_roccq(), GST_host_list, GST_host_list_size, GST_neighbour_list_clean(), GST_opq_openfds, GST_route_list_clear(), GST_slave_list_clear(), GST_stats_destroy(), hostname, id, LOG_DEBUG, Context::master_ip, and Context::system.

Referenced by testbed_run().

Here is the call graph for this function:

Here is the caller graph for this function:

client_connect_cb()

static void* client_connect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  client, struct GNUNET_MQ_Handle *  mq  )

static

Callback for client connect.

Parameters

cls	NULL
client	the client which has disconnected
mq	queue for sending messages to client

Returns

client

Definition at line 787 of file gnunet-service-testbed.c.

{
  return client;
}

client_disconnect_cb()

static void client_disconnect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  client, void *  app_ctx  )

static

Callback for client disconnect.

Parameters

cls	NULL
client	the client which has disconnected
app_ctx	should match client

Definition at line 803 of file gnunet-service-testbed.c.

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

References ForwardedOperationContext::client, Context::client, fopcq_head, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_cancel(), GST_context, GST_forwarded_operation_timeout(), GST_link_notify_disconnect(), GST_notify_client_disconnect_oc(), GST_notify_client_disconnect_peers(), LOG, ForwardedOperationContext::next, and ForwardedOperationContext::timeout_task.

Here is the call graph for this function:

testbed_run()

static void testbed_run ( void *  cls, const struct GNUNET_CONFIGURATION_Handle *  cfg, struct GNUNET_SERVICE_Handle *  service  )

static

Testbed setup.

Parameters

cls	closure
cfg	configuration to use
service	the initialized server

Definition at line 848 of file gnunet-service-testbed.c.

{
  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",
                                                      &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);
}

References cfg, GNUNET_assert, GNUNET_break, GNUNET_CONFIGURATION_dup(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_free, GNUNET_log_setup(), GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), GNUNET_TESTBED_operation_queue_create_(), GST_barriers_init(), GST_cache_init(), GST_config, GST_connection_pool_init(), GST_opq_openfds, GST_stats_init(), GST_timeout, hostname, LOG_DEBUG, OPERATION_QUEUE_TYPE_FIXED, and shutdown_task().

Here is the call graph for this function:

GNUNET_SERVICE_MAIN()

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()
	)

Define "main" method using service macro.

Variable Documentation

GST_config

struct GNUNET_CONFIGURATION_Handle* GST_config

Our configuration.

Definition at line 39 of file gnunet-service-testbed.c.

Referenced by handle_init(), shutdown_task(), and testbed_run().

GST_context

struct Context* GST_context

The master context; generated with the first INIT message.

Definition at line 44 of file gnunet-service-testbed.c.

Referenced by client_disconnect_cb(), GST_find_dest_route(), handle_add_host(), handle_barrier_cancel(), handle_barrier_init(), handle_barrier_status(), handle_init(), handle_link_controllers(), handle_peer_create(), handle_peer_start(), handle_peer_stop(), shutdown_task(), and update_peer_config().

GST_host_list

struct GNUNET_TESTBED_Host** GST_host_list

Array of hosts.

Definition at line 49 of file gnunet-service-testbed.c.

Referenced by forward_overlay_connect(), GST_queue_host_registration(), handle_link_controllers(), handle_overlay_connect(), handle_slave_get_config(), host_list_add(), hr_completion(), lcf_proc_task(), opstart_neighbour_conn(), register_host(), register_next_host(), shutdown_task(), slave_event_cb(), and slave_status_cb().

fopcq_head

struct ForwardedOperationContext* fopcq_head

DLL head for forwarded operation contexts.

Definition at line 54 of file gnunet-service-testbed.c.

Referenced by client_disconnect_cb(), forward_overlay_connect(), GST_clear_fopcq(), GST_forwarded_operation_reply_relay(), GST_forwarded_operation_timeout(), GST_notify_client_disconnect_oc(), GST_notify_client_disconnect_peers(), GST_process_next_focc(), handle_manage_peer_service(), handle_peer_create(), handle_peer_destroy(), handle_peer_get_config(), handle_peer_reconfigure(), handle_peer_start(), handle_peer_stop(), handle_shutdown_peers(), and shutdown_peers_reply_cb().

fopcq_tail

struct ForwardedOperationContext* fopcq_tail

DLL tail for forwarded operation contexts.

Definition at line 59 of file gnunet-service-testbed.c.

Referenced by forward_overlay_connect(), GST_clear_fopcq(), GST_forwarded_operation_reply_relay(), GST_forwarded_operation_timeout(), GST_process_next_focc(), handle_manage_peer_service(), handle_peer_create(), handle_peer_destroy(), handle_peer_get_config(), handle_peer_reconfigure(), handle_peer_start(), handle_peer_stop(), handle_shutdown_peers(), and shutdown_peers_reply_cb().

GST_opq_openfds

struct OperationQueue* GST_opq_openfds

Operation queue for open file descriptors.

Definition at line 64 of file gnunet-service-testbed.c.

Referenced by GST_connection_pool_get_handle(), GST_neighbour_get_connection(), shutdown_task(), and testbed_run().

GST_timeout

struct GNUNET_TIME_Relative GST_timeout

Timeout for operations which may take some time.

Definition at line 64 of file gnunet-service-testbed.c.

Referenced by forward_overlay_connect(), GST_process_next_focc(), handle_link_controllers(), handle_manage_peer_service(), handle_overlay_connect(), handle_peer_create(), handle_peer_destroy(), handle_peer_get_config(), handle_peer_reconfigure(), handle_peer_start(), handle_peer_stop(), handle_remote_overlay_connect(), lcf_proc_task(), and testbed_run().

GST_host_list_size

unsigned int GST_host_list_size

The size of the host list.

Definition at line 74 of file gnunet-service-testbed.c.

Referenced by handle_link_controllers(), host_list_add(), and shutdown_task().

GST_peer_list_size

unsigned int GST_peer_list_size

The size of the peer list.

Definition at line 79 of file gnunet-service-testbed.c.

Referenced by check_remote_overlay_connect(), GST_destroy_peers(), handle_manage_peer_service(), peer_list_add(), and peer_list_remove().

hostname

char* hostname

static

Our hostname; we give this to all the peers we start.

Definition at line 89 of file gnunet-service-testbed.c.

Referenced by add_host(), add_services(), append_port(), check_config(), gen_rsh_args(), get_server_addresses(), GNUNET_CLIENT_test(), GNUNET_CONNECTION_create_from_connect(), GNUNET_HOSTLIST_server_start(), GNUNET_RESOLVER_hostname_resolve(), GNUNET_RESOLVER_ip_get(), GNUNET_RESOLVER_local_fqdn_get(), GNUNET_TESTBED_controller_start(), GNUNET_TESTBED_create_helper_init_msg_(), GNUNET_TESTBED_host_create(), GNUNET_TESTBED_host_create_with_id(), GNUNET_TESTBED_host_resolve_(), GNUNET_TESTBED_hosts_load_from_file(), GNUNET_TESTBED_is_host_habitable(), GNUNET_TESTBED_register_host(), GNUNET_TESTING_system_create(), GNUNET_TESTING_system_create_with_portrange(), GST_stats_init(), handle_add_host(), handle_get(), handle_init(), handle_response(), helper_mst(), http_common_dns_reverse_lookup_cb(), LEGACY_SERVICE_get_server_addresses(), numeric_resolution(), pack(), print_hostname(), process_get(), queue(), resolve_and_cache(), server_get_addresses(), shutdown_task(), test_service_configuration(), testbed_run(), tokenizer_cb(), and try_cache().