testbed_api.h File Reference

Interface for functions internally exported from testbed_api.c. More...

#include "gnunet_util_lib.h"
#include "gnunet_testbed_service.h"
#include "testbed.h"
#include "testbed_helper.h"

Include dependency graph for testbed_api.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	OperationContext
	Context information for GNUNET_TESTBED_Operation. More...
struct	GNUNET_TESTBED_Controller
	Handle to interact with a GNUnet testbed controller. More...
struct	GNUNET_TESTBED_Barrier
	Handle for barrier. More...

Macros
#define	HELPER_TESTBED_BINARY   "gnunet-helper-testbed"
	Testbed Helper binary name. More...

Typedefs
typedef void(*	TESTBED_opcq_empty_cb) (void *cls)
	Operation empty callback. More...

Enumerations
enum	OperationType {   SOLVER_OP_ADD_ADDRESS , SOLVER_OP_DEL_ADDRESS , SOLVER_OP_START_SET_PROPERTY , SOLVER_OP_STOP_SET_PROPERTY ,   SOLVER_OP_START_SET_PREFERENCE , SOLVER_OP_STOP_SET_PREFERENCE , SOLVER_OP_START_REQUEST , SOLVER_OP_STOP_REQUEST ,   OP_PEER_CREATE , OP_PEER_START , OP_PEER_STOP , OP_PEER_DESTROY ,   OP_PEER_INFO , OP_PEER_RECONFIGURE , OP_OVERLAY_CONNECT , OP_FORWARDED ,   OP_LINK_CONTROLLERS , OP_GET_SLAVE_CONFIG , OP_SHUTDOWN_PEERS , OP_MANAGE_SERVICE }
	Enumeration of operations. More...
enum	OperationContextState { OPC_STATE_INIT = 0 , OPC_STATE_STARTED , OPC_STATE_FINISHED }
	Enumeration of states of OperationContext. More...

Functions
void	GNUNET_TESTBED_queue_message_ (struct GNUNET_TESTBED_Controller *controller, struct GNUNET_MessageHeader *msg)
	Queues a message in send queue for sending to the service. More...
void	GNUNET_TESTBED_insert_opc_ (struct GNUNET_TESTBED_Controller *c, struct OperationContext *opc)
	Inserts the given operation context into the operation context map of the given controller. More...
void	GNUNET_TESTBED_remove_opc_ (const struct GNUNET_TESTBED_Controller *c, struct OperationContext *opc)
	Removes the given operation context from the operation context map of the given controller. More...
size_t	GNUNET_TESTBED_compress_config_ (const char *config, size_t size, char **xconfig)
	Compresses given configuration using zlib compress. More...
char *	GNUNET_TESTBED_compress_cfg_ (const struct GNUNET_CONFIGURATION_Handle *cfg, size_t *size, size_t *xsize)
	Function to serialize and compress using zlib a configuration through a configuration handle. More...
struct GNUNET_TESTBED_HelperInit *	GNUNET_TESTBED_create_helper_init_msg_ (const char *cname, const char *hostname, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Creates a helper initialization message. More...
struct OperationContext *	GNUNET_TESTBED_forward_operation_msg_ (struct GNUNET_TESTBED_Controller *controller, uint64_t operation_id, const struct GNUNET_MessageHeader *msg, GNUNET_MQ_MessageCallback cc, void *cc_cls)
	Sends the given message as an operation. More...
void	GNUNET_TESTBED_forward_operation_msg_cancel_ (struct OperationContext *opc)
	Function to cancel an operation created by simply forwarding an operation message. More...
struct GNUNET_CONFIGURATION_Handle *	GNUNET_TESTBED_extract_config_ (const struct GNUNET_MessageHeader *msg)
	Generates configuration by uncompressing configuration in given message. More...
const char *	GNUNET_TESTBED_parse_error_string_ (const struct GNUNET_TESTBED_OperationFailureEventMessage *msg)
	Checks the integrity of the OpeationFailureEventMessage and if good returns the error message it contains. More...
uint64_t	GNUNET_TESTBED_get_next_op_id (struct GNUNET_TESTBED_Controller *controller)
	Function to return the operation id for a controller. More...
struct GNUNET_TESTBED_Operation *	GNUNET_TESTBED_get_slave_config_ (void *op_cls, struct GNUNET_TESTBED_Controller *master, uint32_t slave_host_id)
	Like GNUNET_TESTBED_get_slave_config(), however without the host registration check. More...
struct GNUNET_TESTBED_Barrier *	GNUNET_TESTBED_barrier_init_ (struct GNUNET_TESTBED_Controller *controller, const char *name, unsigned int quorum, GNUNET_TESTBED_barrier_status_cb cb, void *cls, int echo)
	Initialise a barrier and call the given callback when the required percentage of peers (quorum) reach the barrier OR upon error. More...
void	GNUNET_TESTBED_barrier_remove_ (struct GNUNET_TESTBED_Barrier *barrier)
	Remove a barrier and it was the last one in the barrier hash map, destroy the hash map. More...

Detailed Description

Interface for functions internally exported from testbed_api.c.

Author

Sree Harsha Totakura

Definition in file testbed_api.h.

Macro Definition Documentation

HELPER_TESTBED_BINARY

#define HELPER_TESTBED_BINARY   "gnunet-helper-testbed"

Testbed Helper binary name.

Definition at line 38 of file testbed_api.h.

Typedef Documentation

TESTBED_opcq_empty_cb

typedef void(* TESTBED_opcq_empty_cb) (void *cls)

Operation empty callback.

Parameters

cls

closure

Definition at line 180 of file testbed_api.h.

Enumeration Type Documentation

OperationType

enum OperationType

Enumeration of operations.

Enumerator
SOLVER_OP_ADD_ADDRESS
SOLVER_OP_DEL_ADDRESS
SOLVER_OP_START_SET_PROPERTY
SOLVER_OP_STOP_SET_PROPERTY
SOLVER_OP_START_SET_PREFERENCE
SOLVER_OP_STOP_SET_PREFERENCE
SOLVER_OP_START_REQUEST
SOLVER_OP_STOP_REQUEST
OP_PEER_CREATE	Peer create operation.
OP_PEER_START	Peer start operation.
OP_PEER_STOP	Peer stop operation.
OP_PEER_DESTROY	Peer destroy operation.
OP_PEER_INFO	Get peer information operation.
OP_PEER_RECONFIGURE	Reconfigure a peer.
OP_OVERLAY_CONNECT	Overlay connection operation.
OP_FORWARDED	Forwarded operation.
OP_LINK_CONTROLLERS	Link controllers operation.
OP_GET_SLAVE_CONFIG	Get slave config operation.
OP_SHUTDOWN_PEERS	Stop and destroy all peers.
OP_MANAGE_SERVICE	Start/stop service at a peer.

Definition at line 44 of file testbed_api.h.

{
  OP_PEER_CREATE,
 
  OP_PEER_START,
 
  OP_PEER_STOP,
 
  OP_PEER_DESTROY,
 
  OP_PEER_INFO,
 
  OP_PEER_RECONFIGURE,
 
  OP_OVERLAY_CONNECT,
 
  OP_FORWARDED,
 
  OP_LINK_CONTROLLERS,
 
  OP_GET_SLAVE_CONFIG,
 
  OP_SHUTDOWN_PEERS,
 
  OP_MANAGE_SERVICE
};

OperationContextState

enum OperationContextState

Enumeration of states of OperationContext.

Enumerator
OPC_STATE_INIT	The initial state where the associated operation has just been created and is waiting in the operation queues to be started.
OPC_STATE_STARTED	The operation has been started. It may occupy some resources which are to be freed if cancelled.
OPC_STATE_FINISHED	The operation has finished. The end results of this operation may occupy some resources which are to be freed by operation_done

Definition at line 111 of file testbed_api.h.

{
  OPC_STATE_INIT = 0,
 
  OPC_STATE_STARTED,
 
  OPC_STATE_FINISHED
};

Function Documentation

GNUNET_TESTBED_queue_message_()

void GNUNET_TESTBED_queue_message_	(	struct GNUNET_TESTBED_Controller *	controller,
		struct GNUNET_MessageHeader *	msg
	)

Queues a message in send queue for sending to the service.

Parameters

controller	the handle to the controller
msg	the message to queue

Deprecated:

Parameters

controller	the handle to the controller
msg	the message to queue

Definition at line 1336 of file testbed_api.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *m2;
  uint16_t type;
  uint16_t size;
 
  type = ntohs (msg->type);
  size = ntohs (msg->size);
  GNUNET_assert ((GNUNET_MESSAGE_TYPE_TESTBED_INIT <= type) &&
                 (GNUNET_MESSAGE_TYPE_TESTBED_MAX > type));
  env = GNUNET_MQ_msg_extra (m2, size - sizeof(*m2), type);
  GNUNET_memcpy (m2, msg, size);
  GNUNET_free (msg);
  GNUNET_MQ_send (controller->mq, env);
}

References env, GNUNET_assert, GNUNET_free, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TESTBED_INIT, GNUNET_MESSAGE_TYPE_TESTBED_MAX, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_TESTBED_Controller::mq, msg, GNUNET_MessageHeader::size, size, GNUNET_MessageHeader::type, and type.

Referenced by GNUNET_TESTBED_register_host(), handle_barrier_status(), handle_remote_overlay_connect(), opstart_get_slave_config(), opstart_link_controllers(), opstart_peer_getinfo(), and send_hello_thru_rocc().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_insert_opc_()

void GNUNET_TESTBED_insert_opc_	(	struct GNUNET_TESTBED_Controller *	c,
		struct OperationContext *	opc
	)

Inserts the given operation context into the operation context map of the given controller.

Creates the operation context map if one does not exist for the controller

Parameters

c	the controller
opc	the operation context to be inserted

Definition at line 298 of file testbed_api.c.

{
  if (NULL == c->opc_map)
    c->opc_map = GNUNET_CONTAINER_multihashmap32_create (256);
  GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap32_put (
                   c->opc_map,
                   (uint32_t) opc->id,
                   opc,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap32_create(), GNUNET_CONTAINER_multihashmap32_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_OK, OperationContext::id, SearchContext::opc, and GNUNET_TESTBED_Controller::opc_map.

Referenced by GNUNET_TESTBED_forward_operation_msg_(), opstart_get_slave_config(), opstart_link_controllers(), opstart_manage_service(), opstart_overlay_connect(), opstart_peer_create(), opstart_peer_destroy(), opstart_peer_getinfo(), opstart_peer_reconfigure(), opstart_peer_start(), opstart_peer_stop(), and opstart_shutdown_peers().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_remove_opc_()

void GNUNET_TESTBED_remove_opc_	(	const struct GNUNET_TESTBED_Controller *	c,
		struct OperationContext *	opc
	)

Removes the given operation context from the operation context map of the given controller.

Parameters

c	the controller
opc	the operation context to remove

Definition at line 319 of file testbed_api.c.

{
  GNUNET_assert (NULL != c->opc_map);
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multihashmap32_remove (c->opc_map,
                                                         (uint32_t) opc->id,
                                                         opc));
  if ((0 == GNUNET_CONTAINER_multihashmap32_size (c->opc_map)) &&
      (NULL != c->opcq_empty_cb))
    c->opcq_empty_cb (c->opcq_empty_cls);
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap32_remove(), GNUNET_CONTAINER_multihashmap32_size(), GNUNET_YES, OperationContext::id, SearchContext::opc, GNUNET_TESTBED_Controller::opc_map, GNUNET_TESTBED_Controller::opcq_empty_cb, and GNUNET_TESTBED_Controller::opcq_empty_cls.

Referenced by GNUNET_TESTBED_forward_operation_msg_cancel_(), handle_forwarded_operation_msg(), handle_link_controllers_result(), handle_op_fail_event(), handle_opsuccess(), handle_peer_conevent(), handle_peer_config(), handle_peer_create_success(), handle_peer_event(), handle_slave_config(), oprelease_get_slave_config(), oprelease_link_controllers(), oprelease_manage_service(), oprelease_overlay_connect(), oprelease_peer_create(), oprelease_peer_destroy(), oprelease_peer_getinfo(), oprelease_peer_reconfigure(), oprelease_peer_start(), oprelease_peer_stop(), and oprelease_shutdown_peers().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_compress_config_()

size_t GNUNET_TESTBED_compress_config_	(	const char *	config,
		size_t	size,
		char **	xconfig
	)

Compresses given configuration using zlib compress.

Parameters

config	the serialized configuration
size	the size of config
xconfig	will be set to the compressed configuration (memory is fresly allocated)

Returns

the size of the xconfig

Definition at line 1758 of file testbed_api.c.

{
  size_t xsize;
 
  xsize = compressBound ((uLong) size);
  *xconfig = GNUNET_malloc (xsize);
  GNUNET_assert (Z_OK == compress2 ((Bytef *) *xconfig,
                                    (uLongf *) &xsize,
                                    (const Bytef *) config,
                                    (uLongf) size,
                                    Z_BEST_SPEED));
  return xsize;
}

References config, GNUNET_assert, GNUNET_malloc, and size.

Referenced by GNUNET_TESTBED_compress_cfg_(), GNUNET_TESTBED_create_helper_init_msg_(), GNUNET_TESTBED_register_host(), handle_peer_get_config(), handle_slave_get_config(), opstart_peer_create(), opstart_peer_reconfigure(), and tokenizer_cb().

Here is the caller graph for this function:

GNUNET_TESTBED_compress_cfg_()

char* GNUNET_TESTBED_compress_cfg_	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		size_t *	size,
		size_t *	xsize
	)

Function to serialize and compress using zlib a configuration through a configuration handle.

Parameters

cfg	the configuration
size	the size of configuration when serialize. Will be set on success.
xsize	the sizeo of the compressed configuration. Will be set on success.

Returns

the serialized and compressed configuration

Definition at line 1785 of file testbed_api.c.

{
  char *config;
  char *xconfig;
  size_t size_;
  size_t xsize_;
 
  config = GNUNET_CONFIGURATION_serialize (cfg, &size_);
  xsize_ = GNUNET_TESTBED_compress_config_ (config, size_, &xconfig);
  GNUNET_free (config);
  *size = size_;
  *xsize = xsize_;
  return xconfig;
}

References cfg, config, GNUNET_CONFIGURATION_serialize(), GNUNET_free, GNUNET_TESTBED_compress_config_(), and size.

Referenced by send_controller_link_response().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_create_helper_init_msg_()

struct GNUNET_TESTBED_HelperInit* GNUNET_TESTBED_create_helper_init_msg_	(	const char *	trusted_ip,
		const char *	hostname,
		const struct GNUNET_CONFIGURATION_Handle *	cfg
	)

Creates a helper initialization message.

This function is here because we want to use this in testing

Parameters

trusted_ip	the ip address of the controller which will be set as TRUSTED HOST(all connections form this ip are permitted by the testbed) when starting testbed controller at host. This can either be a single ip address or a network address in CIDR notation.
hostname	the hostname of the destination this message is intended for
cfg	the configuration that has to used to start the testbed service thru helper

Returns

the initialization message

This function is here because we want to use this in testing

Parameters

trusted_ip	the ip address of the controller which will be set as TRUSTED HOST(all connections from this ip are permitted by the testbed) when starting testbed controller at host. This can either be a single ip address or a network address in CIDR notation.
hostname	the hostname of the destination this message is intended for
cfg	the configuration that has to used to start the testbed service thru helper

Returns

the initialization message

Definition at line 1957 of file testbed_api.c.

{
  struct GNUNET_TESTBED_HelperInit *msg;
  char *config;
  char *xconfig;
  size_t config_size;
  size_t xconfig_size;
  uint16_t trusted_ip_len;
  uint16_t hostname_len;
  uint16_t msg_size;
 
  config = GNUNET_CONFIGURATION_serialize (cfg, &config_size);
  GNUNET_assert (NULL != config);
  xconfig_size =
    GNUNET_TESTBED_compress_config_ (config, config_size, &xconfig);
  GNUNET_free (config);
  trusted_ip_len = strlen (trusted_ip);
  hostname_len = (NULL == hostname) ? 0 : strlen (hostname);
  msg_size = xconfig_size + trusted_ip_len + 1
             + sizeof(struct GNUNET_TESTBED_HelperInit);
  msg_size += hostname_len;
  msg = GNUNET_realloc (xconfig, msg_size);
  (void) memmove (((void *) &msg[1]) + trusted_ip_len + 1 + hostname_len,
                  msg,
                  xconfig_size);
  msg->header.size = htons (msg_size);
  msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_HELPER_INIT);
  msg->trusted_ip_size = htons (trusted_ip_len);
  msg->hostname_size = htons (hostname_len);
  msg->config_size = htons (config_size);
  (void) strcpy ((char *) &msg[1], trusted_ip);
  if (0 != hostname_len)
    GNUNET_memcpy ((char *) &msg[1] + trusted_ip_len + 1,
                   hostname,
                   hostname_len);
  return msg;
}

References cfg, config, GNUNET_TESTBED_HelperInit::config_size, GNUNET_assert, GNUNET_CONFIGURATION_serialize(), GNUNET_free, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TESTBED_HELPER_INIT, GNUNET_realloc, GNUNET_TESTBED_compress_config_(), hostname, msg, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by GNUNET_TESTBED_controller_start().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_forward_operation_msg_()

struct OperationContext* GNUNET_TESTBED_forward_operation_msg_	(	struct GNUNET_TESTBED_Controller *	controller,
		uint64_t	operation_id,
		const struct GNUNET_MessageHeader *	msg,
		GNUNET_MQ_MessageCallback	cc,
		void *	cc_cls
	)

Sends the given message as an operation.

The given callback is called when a reply for the operation is available. Call GNUNET_TESTBED_forward_operation_msg_cancel_() to cleanup the returned operation context if the cc hasn't been called

Parameters

controller	the controller to which the message has to be sent
operation_id	the operation id of the message
msg	the message to send
cc	the callback to call when reply is available
cc_cls	the closure for the above callback

Returns

the operation context which can be used to cancel the forwarded operation

Definition at line 1370 of file testbed_api.c.

{
  struct OperationContext *opc;
  struct ForwardedOperationData *data;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *m2;
  uint16_t type = ntohs (msg->type);
  uint16_t size = ntohs (msg->size);
 
  env = GNUNET_MQ_msg_extra (m2, size - sizeof(*m2), type);
  GNUNET_memcpy (m2, msg, size);
  GNUNET_MQ_send (controller->mq, env);
  data = GNUNET_new (struct ForwardedOperationData);
  data->cc = cc;
  data->cc_cls = cc_cls;
  opc = GNUNET_new (struct OperationContext);
  opc->c = controller;
  opc->type = OP_FORWARDED;
  opc->data = data;
  opc->id = operation_id;
  GNUNET_TESTBED_insert_opc_ (controller, opc);
  return opc;
}

References OperationContext::c, OperationContext::data, data, env, GNUNET_memcpy, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_TESTBED_insert_opc_(), OperationContext::id, GNUNET_TESTBED_Controller::mq, msg, OP_FORWARDED, GNUNET_MessageHeader::size, size, GNUNET_MessageHeader::type, OperationContext::type, and type.

Referenced by forward_overlay_connect(), 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(), opstart_service_connect(), and p2_controller_connect_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_forward_operation_msg_cancel_()

void GNUNET_TESTBED_forward_operation_msg_cancel_

(

struct OperationContext *

opc

)

Function to cancel an operation created by simply forwarding an operation message.

Parameters

opc	the operation context from GNUNET_TESTBED_forward_operation_msg_()

Definition at line 1407 of file testbed_api.c.

{
  GNUNET_TESTBED_remove_opc_ (opc->c, opc);
  GNUNET_free (opc->data);
  GNUNET_free (opc);
}

References OperationContext::c, OperationContext::data, GNUNET_free, and GNUNET_TESTBED_remove_opc_().

Referenced by cleanup_occ_rp2c(), GST_clear_fopcq(), GST_forwarded_operation_timeout(), and oprelease_service_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_extract_config_()

struct GNUNET_CONFIGURATION_Handle* GNUNET_TESTBED_extract_config_

(

const struct GNUNET_MessageHeader *

msg

)

Generates configuration by uncompressing configuration in given message.

The given message should be of the following types: #GNUNET_MESSAGE_TYPE_TESTBED_PEERCONFIG, #GNUNET_MESSAGE_TYPE_TESTBED_SLAVECONFIG

Parameters

msg	the message containing compressed configuration

Returns

handle to the parsed configuration

The given message should be of the following types: GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION, GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION, GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST, GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS, GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT,

FIXME: This API is incredibly ugly.

Parameters

msg	the message containing compressed configuration

Returns

handle to the parsed configuration; NULL upon error while parsing the message

Definition at line 2043 of file testbed_api.c.

{
  struct GNUNET_CONFIGURATION_Handle *cfg;
  Bytef *data;
  const Bytef *xdata;
  uLong data_len;
  uLong xdata_len;
  int ret;
 
  switch (ntohs (msg->type))
  {
  case GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION: {
      const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *imsg;
 
      imsg =
        (const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *) msg;
      data_len = (uLong) ntohs (imsg->config_size);
      xdata_len =
        ntohs (imsg->header.size)
        - sizeof(struct GNUNET_TESTBED_PeerConfigurationInformationMessage);
      xdata = (const Bytef *) &imsg[1];
    }
    break;
 
  case GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION: {
      const struct GNUNET_TESTBED_SlaveConfiguration *imsg;
 
      imsg = (const struct GNUNET_TESTBED_SlaveConfiguration *) msg;
      data_len = (uLong) ntohs (imsg->config_size);
      xdata_len = ntohs (imsg->header.size)
                  - sizeof(struct GNUNET_TESTBED_SlaveConfiguration);
      xdata = (const Bytef *) &imsg[1];
    }
    break;
 
  case GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST: {
      const struct GNUNET_TESTBED_AddHostMessage *imsg;
      uint16_t osize;
 
      imsg = (const struct GNUNET_TESTBED_AddHostMessage *) msg;
      data_len = (uLong) ntohs (imsg->config_size);
      osize = sizeof(struct GNUNET_TESTBED_AddHostMessage)
              + ntohs (imsg->username_length) + ntohs (imsg->hostname_length);
      xdata_len = ntohs (imsg->header.size) - osize;
      xdata = (const Bytef *) ((const void *) imsg + osize);
    }
    break;
 
  case GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT: {
      const struct GNUNET_TESTBED_ControllerLinkResponse *imsg;
 
      imsg = (const struct GNUNET_TESTBED_ControllerLinkResponse *) msg;
      data_len = ntohs (imsg->config_size);
      xdata_len = ntohs (imsg->header.size)
                  - sizeof(const struct GNUNET_TESTBED_ControllerLinkResponse);
      xdata = (const Bytef *) &imsg[1];
    }
    break;
 
  case GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER: {
      const struct GNUNET_TESTBED_PeerCreateMessage *imsg;
 
      imsg = (const struct GNUNET_TESTBED_PeerCreateMessage *) msg;
      data_len = ntohs (imsg->config_size);
      xdata_len = ntohs (imsg->header.size)
                  - sizeof(struct GNUNET_TESTBED_PeerCreateMessage);
      xdata = (const Bytef *) &imsg[1];
    }
    break;
 
  case GNUNET_MESSAGE_TYPE_TESTBED_RECONFIGURE_PEER: {
      const struct GNUNET_TESTBED_PeerReconfigureMessage *imsg;
 
      imsg = (const struct GNUNET_TESTBED_PeerReconfigureMessage *) msg;
      data_len = ntohs (imsg->config_size);
      xdata_len = ntohs (imsg->header.size)
                  - sizeof(struct GNUNET_TESTBED_PeerReconfigureMessage);
      xdata = (const Bytef *) &imsg[1];
    }
    break;
 
  default:
    GNUNET_assert (0);
  }
  data = GNUNET_malloc (data_len);
  if (Z_OK != (ret = uncompress (data, &data_len, xdata, xdata_len)))
  {
    GNUNET_free (data);
    GNUNET_break_op (0);  /* Un-compression failure */
    return NULL;
  }
  cfg = GNUNET_CONFIGURATION_create ();
  if (GNUNET_OK != GNUNET_CONFIGURATION_deserialize (cfg,
                                                     (const char *) data,
                                                     (size_t) data_len,
                                                     NULL))
  {
    GNUNET_free (data);
    GNUNET_break_op (0);  /* De-serialization failure */
    return NULL;
  }
  GNUNET_free (data);
  return cfg;
}

References cfg, GNUNET_TESTBED_AddHostMessage::config_size, GNUNET_TESTBED_ControllerLinkResponse::config_size, GNUNET_TESTBED_PeerCreateMessage::config_size, GNUNET_TESTBED_PeerReconfigureMessage::config_size, GNUNET_TESTBED_PeerConfigurationInformationMessage::config_size, GNUNET_TESTBED_SlaveConfiguration::config_size, data, GNUNET_assert, GNUNET_break_op, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_deserialize(), GNUNET_free, GNUNET_malloc, GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST, GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER, GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT, GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION, GNUNET_MESSAGE_TYPE_TESTBED_RECONFIGURE_PEER, GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION, GNUNET_OK, GNUNET_TESTBED_AddHostMessage::header, GNUNET_TESTBED_ControllerLinkResponse::header, GNUNET_TESTBED_PeerCreateMessage::header, GNUNET_TESTBED_PeerReconfigureMessage::header, GNUNET_TESTBED_PeerConfigurationInformationMessage::header, GNUNET_TESTBED_SlaveConfiguration::header, GNUNET_TESTBED_AddHostMessage::hostname_length, msg, ret, GNUNET_MessageHeader::size, GNUNET_MessageHeader::type, and GNUNET_TESTBED_AddHostMessage::username_length.

Referenced by configuration_receiver(), handle_add_host(), handle_link_controllers_result(), handle_peer_config(), handle_peer_create(), handle_peer_reconfigure(), and handle_slave_config().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_parse_error_string_()

const char* GNUNET_TESTBED_parse_error_string_

(

const struct GNUNET_TESTBED_OperationFailureEventMessage *

msg

)

Checks the integrity of the OpeationFailureEventMessage and if good returns the error message it contains.

Parameters

msg	the OperationFailureEventMessage

Returns

the error message

Definition at line 2150 of file testbed_api.c.

{
  uint16_t msize;
  const char *emsg;
 
  msize = ntohs (msg->header.size);
  if (sizeof(struct GNUNET_TESTBED_OperationFailureEventMessage) >= msize)
    return NULL;
  msize -= sizeof(struct GNUNET_TESTBED_OperationFailureEventMessage);
  emsg = (const char *) &msg[1];
  if ('\0' != emsg[msize - 1])
  {
    GNUNET_break (0);
    return NULL;
  }
  return emsg;
}

References GNUNET_break, msg, and GNUNET_MessageHeader::size.

Referenced by configuration_receiver(), and handle_op_fail_event().

Here is the caller graph for this function:

GNUNET_TESTBED_get_next_op_id()

uint64_t GNUNET_TESTBED_get_next_op_id

(

struct GNUNET_TESTBED_Controller *

controller

)

Function to return the operation id for a controller.

The operation id is created from the controllers host id and its internal operation counter.

Parameters

controller

the handle to the controller whose operation id has to be incremented

Returns

the incremented operation id.

Definition at line 2178 of file testbed_api.c.

{
  uint64_t op_id;
 
  op_id = (uint64_t) GNUNET_TESTBED_host_get_id_ (controller->host);
  op_id = op_id << 32;
  op_id |= (uint64_t) controller->operation_counter++;
  return op_id;
}

References GNUNET_TESTBED_host_get_id_(), GNUNET_TESTBED_Controller::host, and GNUNET_TESTBED_Controller::operation_counter.

Referenced by GNUNET_TESTBED_controller_link(), GNUNET_TESTBED_get_slave_config_(), GNUNET_TESTBED_overlay_connect(), GNUNET_TESTBED_peer_create(), GNUNET_TESTBED_peer_destroy(), GNUNET_TESTBED_peer_get_information(), GNUNET_TESTBED_peer_manage_service(), GNUNET_TESTBED_peer_start(), GNUNET_TESTBED_peer_stop(), GNUNET_TESTBED_peer_update_configuration(), GNUNET_TESTBED_shutdown_peers(), and opstart_service_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_get_slave_config_()

struct GNUNET_TESTBED_Operation* GNUNET_TESTBED_get_slave_config_	(	void *	op_cls,
		struct GNUNET_TESTBED_Controller *	master,
		uint32_t	slave_host_id
	)

Like GNUNET_TESTBED_get_slave_config(), however without the host registration check.

Another difference is that this function takes the id of the slave host.

Parameters

op_cls	the closure for the operation
master	the handle to master controller
slave_host_id	id of the host where the slave controller is running to the slave_host should remain valid until this operation is cancelled or marked as finished

Returns

the operation handle;

Definition at line 1894 of file testbed_api.c.

{
  struct OperationContext *opc;
  struct GetSlaveConfigData *data;
 
  data = GNUNET_new (struct GetSlaveConfigData);
  data->slave_id = slave_host_id;
  opc = GNUNET_new (struct OperationContext);
  opc->state = OPC_STATE_INIT;
  opc->c = master;
  opc->id = GNUNET_TESTBED_get_next_op_id (master);
  opc->type = OP_GET_SLAVE_CONFIG;
  opc->data = data;
  opc->op_cls = op_cls;
  opc->op = GNUNET_TESTBED_operation_create_ (opc,
                                              &opstart_get_slave_config,
                                              &oprelease_get_slave_config);
  GNUNET_TESTBED_operation_queue_insert_ (master->opq_parallel_operations,
                                          opc->op);
  GNUNET_TESTBED_operation_begin_wait_ (opc->op);
  return opc->op;
}

References OperationContext::c, OperationContext::data, data, GNUNET_new, GNUNET_TESTBED_get_next_op_id(), GNUNET_TESTBED_operation_begin_wait_(), GNUNET_TESTBED_operation_create_(), GNUNET_TESTBED_operation_queue_insert_(), OperationContext::id, OperationContext::op, OperationContext::op_cls, OP_GET_SLAVE_CONFIG, OPC_STATE_INIT, GNUNET_TESTBED_Controller::opq_parallel_operations, oprelease_get_slave_config(), opstart_get_slave_config(), OperationContext::state, and OperationContext::type.

Referenced by GNUNET_TESTBED_get_slave_config().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_barrier_init_()

struct GNUNET_TESTBED_Barrier* GNUNET_TESTBED_barrier_init_	(	struct GNUNET_TESTBED_Controller *	controller,
		const char *	name,
		unsigned int	quorum,
		GNUNET_TESTBED_barrier_status_cb	cb,
		void *	cls,
		int	echo
	)

Initialise a barrier and call the given callback when the required percentage of peers (quorum) reach the barrier OR upon error.

Parameters

controller	the handle to the controller
name	identification name of the barrier
quorum	the percentage of peers that is required to reach the barrier. Peers signal reaching a barrier by calling GNUNET_TESTBED_barrier_reached().
cb	the callback to call when the barrier is reached or upon error. Cannot be NULL.
cls	closure for the above callback
echo	GNUNET_YES to echo the barrier crossed status message back to the controller

Returns

barrier handle; NULL upon error

Definition at line 2324 of file testbed_api.c.

{
  struct GNUNET_TESTBED_BarrierInit *msg;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TESTBED_Barrier *barrier;
  struct GNUNET_HashCode key;
  size_t name_len;
 
  GNUNET_assert (quorum <= 100);
  GNUNET_assert (NULL != cb);
  name_len = strlen (name);
  GNUNET_assert (0 < name_len);
  GNUNET_CRYPTO_hash (name, name_len, &key);
  if (NULL == controller->barrier_map)
    controller->barrier_map =
      GNUNET_CONTAINER_multihashmap_create (3, GNUNET_YES);
  if (GNUNET_YES ==
      GNUNET_CONTAINER_multihashmap_contains (controller->barrier_map, &key))
  {
    GNUNET_break (0);
    return NULL;
  }
  LOG_DEBUG ("Initialising barrier `%s'\n", name);
  barrier = GNUNET_new (struct GNUNET_TESTBED_Barrier);
  barrier->c = controller;
  barrier->name = GNUNET_strdup (name);
  barrier->cb = cb;
  barrier->cls = cls;
  barrier->echo = echo;
  GNUNET_memcpy (&barrier->key, &key, sizeof(struct GNUNET_HashCode));
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multihashmap_put (
                   controller->barrier_map,
                   &barrier->key,
                   barrier,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
 
  env = GNUNET_MQ_msg_extra (msg,
                             name_len,
                             GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT);
  msg->quorum = (uint8_t) quorum;
  GNUNET_memcpy (msg->name, barrier->name, name_len);
  GNUNET_MQ_send (barrier->c->mq, env);
  return barrier;
}

References GNUNET_TESTBED_Controller::barrier_map, GNUNET_TESTBED_Barrier::c, GNUNET_TESTBED_Barrier::cb, GNUNET_TESTBED_Barrier::cls, echo, GNUNET_TESTBED_Barrier::echo, env, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_CRYPTO_hash(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_OK, GNUNET_strdup, GNUNET_YES, key, GNUNET_TESTBED_Barrier::key, LOG_DEBUG, GNUNET_TESTBED_Controller::mq, msg, name, and GNUNET_TESTBED_Barrier::name.

Referenced by GNUNET_TESTBED_barrier_init(), and handle_barrier_init().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_barrier_remove_()

void GNUNET_TESTBED_barrier_remove_

(

struct GNUNET_TESTBED_Barrier *

barrier

)

Remove a barrier and it was the last one in the barrier hash map, destroy the hash map.

Parameters

barrier

the barrier to remove

Definition at line 2304 of file testbed_api.c.

{
  struct GNUNET_TESTBED_Controller *c = barrier->c;
 
  GNUNET_assert (NULL != c->barrier_map);  /* No barriers present */
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multihashmap_remove (c->barrier_map,
                                                       &barrier->key,
                                                       barrier));
  GNUNET_free (barrier->name);
  GNUNET_free (barrier);
  if (0 == GNUNET_CONTAINER_multihashmap_size (c->barrier_map))
  {
    GNUNET_CONTAINER_multihashmap_destroy (c->barrier_map);
    c->barrier_map = NULL;
  }
}

References GNUNET_TESTBED_Controller::barrier_map, GNUNET_TESTBED_Barrier::c, GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_free, GNUNET_OK, GNUNET_TESTBED_Barrier::key, and GNUNET_TESTBED_Barrier::name.

Referenced by GNUNET_TESTBED_barrier_cancel(), and handle_barrier_status().

Here is the call graph for this function:

Here is the caller graph for this function: