testbed_api.c File Reference

API for accessing the GNUnet testing service. More...

#include "platform.h"
#include "gnunet_testbed_service.h"
#include "gnunet_core_service.h"
#include "gnunet_constants.h"
#include "gnunet_transport_service.h"
#include "gnunet_hello_lib.h"
#include <zlib.h>
#include "testbed.h"
#include "testbed_api.h"
#include "testbed_api_hosts.h"
#include "testbed_api_peers.h"
#include "testbed_api_operations.h"
#include "testbed_api_sd.h"

Include dependency graph for testbed_api.c:

Go to the source code of this file.

Data Structures
struct	ForwardedOperationData
	Context data for forwarded Operation. More...
struct	GetSlaveConfigData
	Context data for get slave config operations. More...
struct	ControllerLinkData
	Context data for controller link operations. More...
struct	ShutdownPeersData
	Date context for OP_SHUTDOWN_PEERS operations. More...
struct	ExpireOperationEntry
	An entry in the stack for keeping operations which are about to expire. More...
struct	SearchContext
	Context information to be used while searching for operation contexts. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "testbed-api", __VA_ARGS__)
	Generic logging shorthand. More...
#define	LOG_DEBUG(...)   LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
	Debug logging. More...
#define	TIME_REL_SECS(sec)    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, sec)
	Relative time seconds shorthand. More...
#define	TIMEOUT_REL   TIME_REL_SECS (1)
	Default server message sending retry timeout. More...

Functions
static void	exop_insert (struct GNUNET_TESTBED_Operation *op)
	Inserts an operation into the list of operations marked for expiry. More...
static int	exop_check (const struct GNUNET_TESTBED_Operation *const op)
	Checks if an operation is present in the list of operations marked for expiry. More...
static int	opc_search_iterator (void *cls, uint32_t key, void *value)
	Search iterator for searching an operation context. More...
static struct OperationContext *	find_opc (const struct GNUNET_TESTBED_Controller *c, const uint64_t id)
	Returns the operation context with the given id if found in the Operation context queues of the controller. 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...
static int	check_add_host_confirm (void *cls, const struct GNUNET_TESTBED_HostConfirmedMessage *msg)
	Check #GNUNET_MESSAGE_TYPE_TESTBED_ADDHOSTCONFIRM message is well-formed. More...
static void	handle_add_host_confirm (void *cls, const struct GNUNET_TESTBED_HostConfirmedMessage *msg)
	Handler for #GNUNET_MESSAGE_TYPE_TESTBED_ADDHOSTCONFIRM message from controller (testbed service) More...
static void	handle_forwarded_operation_msg (void *cls, struct OperationContext *opc, const struct GNUNET_MessageHeader *msg)
	Handler for forwarded operations. More...
static void	handle_opsuccess (void *cls, const struct GNUNET_TESTBED_GenericOperationSuccessEventMessage *msg)
	Handler for GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS message from controller (testbed service) More...
static void	handle_peer_create_success (void *cls, const struct GNUNET_TESTBED_PeerCreateSuccessEventMessage *msg)
	Handler for GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS message from controller (testbed service) More...
static void	handle_peer_event (void *cls, const struct GNUNET_TESTBED_PeerEventMessage *msg)
	Handler for GNUNET_MESSAGE_TYPE_TESTBED_PEER_EVENT message from controller (testbed service) More...
static void	handle_peer_conevent (void *cls, const struct GNUNET_TESTBED_ConnectionEventMessage *msg)
	Handler for GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT message from controller (testbed service) More...
static int	check_peer_config (void *cls, const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *msg)
	Validate GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION message from controller (testbed service) More...
static void	handle_peer_config (void *cls, const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *msg)
	Handler for GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION message from controller (testbed service) More...
static int	check_op_fail_event (void *cls, const struct GNUNET_TESTBED_OperationFailureEventMessage *msg)
	Validate GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT message from controller (testbed service) More...
static void	handle_op_fail_event (void *cls, const struct GNUNET_TESTBED_OperationFailureEventMessage *msg)
	Handler for GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT message from controller (testbed service) More...
static struct GNUNET_TESTBED_SlaveGetConfigurationMessage *	GNUNET_TESTBED_generate_slavegetconfig_msg_ (uint64_t op_id, uint32_t slave_id)
	Function to build GET_SLAVE_CONFIG message. More...
static int	check_slave_config (void *cls, const struct GNUNET_TESTBED_SlaveConfiguration *msg)
	Validate #GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_INFORMATION message from controller (testbed service) More...
static void	handle_slave_config (void *cls, const struct GNUNET_TESTBED_SlaveConfiguration *msg)
	Handler for GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION message from controller (testbed service) More...
static int	check_link_controllers_result (void *cls, const struct GNUNET_TESTBED_ControllerLinkResponse *msg)
	Check GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT message from controller (testbed service) More...
static void	handle_link_controllers_result (void *cls, const struct GNUNET_TESTBED_ControllerLinkResponse *msg)
	Handler for GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT message from controller (testbed service) More...
static int	check_barrier_status (void *cls, const struct GNUNET_TESTBED_BarrierStatusMsg *msg)
	Validate GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS message. More...
static void	handle_barrier_status (void *cls, const struct GNUNET_TESTBED_BarrierStatusMsg *msg)
	Handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS messages. More...
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...
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...
static void	opstart_link_controllers (void *cls)
	Function to call to start a link-controllers type operation once all queues the operation is part of declare that the operation can be activated. More...
static void	oprelease_link_controllers (void *cls)
	Callback which will be called when link-controllers type operation is released. More...
static void	opstart_get_slave_config (void *cls)
	Function to be called when get slave config operation is ready. More...
static void	oprelease_get_slave_config (void *cls)
	Function to be called when get slave config operation is cancelled or finished. More...
static void	mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
	Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue. More...
struct GNUNET_TESTBED_Controller *	GNUNET_TESTBED_controller_connect (struct GNUNET_TESTBED_Host *host, uint64_t event_mask, GNUNET_TESTBED_ControllerCallback cc, void *cc_cls)
	Start a controller process using the given configuration at the given host. More...
static int	opc_free_iterator (void *cls, uint32_t key, void *value)
	Iterator to free opc map entries. More...
void	GNUNET_TESTBED_controller_disconnect (struct GNUNET_TESTBED_Controller *c)
	Stop the given controller (also will terminate all peers and controllers dependent on this 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_Operation *	GNUNET_TESTBED_controller_link (void *op_cls, struct GNUNET_TESTBED_Controller *master, struct GNUNET_TESTBED_Host *delegated_host, struct GNUNET_TESTBED_Host *slave_host, int is_subordinate)
	Create a link from slave controller to delegated 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_Operation *	GNUNET_TESTBED_get_slave_config (void *op_cls, struct GNUNET_TESTBED_Controller *master, struct GNUNET_TESTBED_Host *slave_host)
	Function to acquire the configuration of a running slave controller. More...
void	GNUNET_TESTBED_overlay_write_topology_to_file (struct GNUNET_TESTBED_Controller *controller, const char *filename)
	Ask the testbed controller to write the current overlay topology to a file. More...
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. More...
void	GNUNET_TESTBED_operation_done (struct GNUNET_TESTBED_Operation *operation)
	This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) from an operation has been fully processed i.e. 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...
static void	opstart_shutdown_peers (void *cls)
	Function called when a shutdown peers operation is ready. More...
static void	oprelease_shutdown_peers (void *cls)
	Callback which will be called when shutdown peers operation is released. More...
struct GNUNET_TESTBED_Operation *	GNUNET_TESTBED_shutdown_peers (struct GNUNET_TESTBED_Controller *c, void *op_cls, GNUNET_TESTBED_OperationCompletionCallback cb, void *cb_cls)
	Stops and destroys all peers. More...
uint32_t	GNUNET_TESTBED_get_index (const struct GNUNET_TESTBED_Peer *peer)
	Return the index of the peer inside of the total peer array, aka. 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...
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...
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 *cb_cls)
	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_cancel (struct GNUNET_TESTBED_Barrier *barrier)
	Cancel a barrier. More...

Variables
static struct ExpireOperationEntry *	exop_head
	DLL head for list of operations marked for expiry. More...
static struct ExpireOperationEntry *	exop_tail
	DLL tail for list of operation marked for expiry. More...

Detailed Description

API for accessing the GNUnet testing service.

This library is supposed to make it easier to write testcases and script large-scale benchmarks.

Author

Christian Grothoff

Sree Harsha Totakura

Definition in file testbed_api.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "testbed-api", __VA_ARGS__)

Generic logging shorthand.

Definition at line 47 of file testbed_api.c.

LOG_DEBUG

#define LOG_DEBUG

(

...

)

LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)

Debug logging.

Definition at line 52 of file testbed_api.c.

TIME_REL_SECS

#define TIME_REL_SECS

(

sec

)

GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, sec)

Relative time seconds shorthand.

Definition at line 57 of file testbed_api.c.

TIMEOUT_REL

#define TIMEOUT_REL   TIME_REL_SECS (1)

Default server message sending retry timeout.

Definition at line 64 of file testbed_api.c.

Function Documentation

exop_insert()

static void exop_insert ( struct GNUNET_TESTBED_Operation *  op )

static

Inserts an operation into the list of operations marked for expiry.

Parameters

op	the operation to insert

Definition at line 169 of file testbed_api.c.

{
  struct ExpireOperationEntry *entry;
 
  entry = GNUNET_new (struct ExpireOperationEntry);
  entry->op = op;
  GNUNET_CONTAINER_DLL_insert_tail (exop_head, exop_tail, entry);
}

References exop_head, exop_tail, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_new, op, and ExpireOperationEntry::op.

Referenced by handle_op_fail_event(), handle_opsuccess(), handle_peer_conevent(), handle_peer_create_success(), and handle_peer_event().

Here is the caller graph for this function:

exop_check()

static int exop_check ( const struct GNUNET_TESTBED_Operation *const  op )

static

Checks if an operation is present in the list of operations marked for expiry.

If the operation is found, it and the tail of operations after it are removed from the list.

Parameters

op	the operation to check

Returns

GNUNET_NO if the operation is not present in the list; GNUNET_YES if the operation is found in the list (the operation is then removed from the list – calling this function again with the same paramenter will return GNUNET_NO)

Definition at line 191 of file testbed_api.c.

{
  struct ExpireOperationEntry *entry;
  struct ExpireOperationEntry *entry2;
  int found;
 
  found = GNUNET_NO;
  entry = exop_head;
  while (NULL != entry)
  {
    if (op == entry->op)
    {
      found = GNUNET_YES;
      break;
    }
    entry = entry->next;
  }
  if (GNUNET_NO == found)
    return GNUNET_NO;
  /* Truncate the tail */
  while (NULL != entry)
  {
    entry2 = entry->next;
    GNUNET_CONTAINER_DLL_remove (exop_head, exop_tail, entry);
    GNUNET_free (entry);
    entry = entry2;
  }
  return GNUNET_YES;
}

References exop_head, exop_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NO, GNUNET_YES, ExpireOperationEntry::next, op, and ExpireOperationEntry::op.

Referenced by GNUNET_TESTBED_operation_done(), handle_op_fail_event(), handle_opsuccess(), handle_peer_conevent(), handle_peer_create_success(), and handle_peer_event().

Here is the caller graph for this function:

opc_search_iterator()

static int opc_search_iterator ( void *  cls, uint32_t  key, void *  value  )

static

Search iterator for searching an operation context.

Parameters

cls	the search context
key	current key code
value	value in the hash map

Returns

GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 249 of file testbed_api.c.

{
  struct SearchContext *sc = cls;
  struct OperationContext *opc = value;
 
  GNUNET_assert (NULL != opc);
  GNUNET_assert (NULL == sc->opc);
  if (opc->id != sc->id)
    return GNUNET_YES;
  sc->opc = opc;
  return GNUNET_NO;
}

References GNUNET_assert, GNUNET_NO, GNUNET_YES, OperationContext::id, sc, and value.

Referenced by find_opc().

Here is the caller graph for this function:

find_opc()

static struct OperationContext* find_opc ( const struct GNUNET_TESTBED_Controller *  c, const uint64_t  id  )

static

Returns the operation context with the given id if found in the Operation context queues of the controller.

Parameters

c	the controller whose operation context map is searched
id	the id which has to be checked

Returns

the matching operation context; NULL if no match found

Definition at line 272 of file testbed_api.c.

{
  struct SearchContext sc;
 
  sc.id = id;
  sc.opc = NULL;
  GNUNET_assert (NULL != c->opc_map);
  if (GNUNET_SYSERR !=
      GNUNET_CONTAINER_multihashmap32_get_multiple (c->opc_map,
                                                    (uint32_t) id,
                                                    &opc_search_iterator,
                                                    &sc))
    return NULL;
  return sc.opc;
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap32_get_multiple(), GNUNET_SYSERR, id, GNUNET_TESTBED_Controller::opc_map, opc_search_iterator(), and sc.

Referenced by handle_link_controllers_result(), handle_op_fail_event(), handle_opsuccess(), handle_peer_conevent(), handle_peer_config(), handle_peer_create_success(), handle_peer_event(), and handle_slave_config().

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:

check_add_host_confirm()

static int check_add_host_confirm ( void *  cls, const struct GNUNET_TESTBED_HostConfirmedMessage *  msg  )

static

Check #GNUNET_MESSAGE_TYPE_TESTBED_ADDHOSTCONFIRM message is well-formed.

Parameters

cls	the controller handler
msg	message received

Returns

GNUNET_OK if message is well-formed

Definition at line 341 of file testbed_api.c.

{
  const char *emsg;
  uint16_t msg_size;
 
  msg_size = ntohs (msg->header.size) - sizeof(*msg);
  if (0 == msg_size)
    return GNUNET_OK;
  /* We have an error message */
  emsg = (const char *) &msg[1];
  if ('\0' != emsg[msg_size - 1])
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

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

handle_add_host_confirm()

static void handle_add_host_confirm ( void *  cls, const struct GNUNET_TESTBED_HostConfirmedMessage *  msg  )

static

Handler for #GNUNET_MESSAGE_TYPE_TESTBED_ADDHOSTCONFIRM message from controller (testbed service)

Parameters

cls	the controller handler
msg	message received

Definition at line 369 of file testbed_api.c.

{
  struct GNUNET_TESTBED_Controller *c = cls;
  struct GNUNET_TESTBED_HostRegistrationHandle *rh = c->rh;
  const char *emsg;
  uint16_t msg_size;
 
  if (NULL == rh)
    return;
  if (GNUNET_TESTBED_host_get_id_ (rh->host) != ntohl (msg->host_id))
  {
    LOG_DEBUG ("Mismatch in host id's %u, %u of host confirm msg\n",
               GNUNET_TESTBED_host_get_id_ (rh->host),
               ntohl (msg->host_id));
    return;
  }
  c->rh = NULL;
  msg_size = ntohs (msg->header.size) - sizeof(*msg);
  if (0 == msg_size)
  {
    LOG_DEBUG ("Host %u successfully registered\n", ntohl (msg->host_id));
    GNUNET_TESTBED_mark_host_registered_at_ (rh->host, c);
    rh->cc (rh->cc_cls, NULL);
    GNUNET_free (rh);
    return;
  }
  /* We have an error message */
  emsg = (const char *) &msg[1];
  LOG (GNUNET_ERROR_TYPE_ERROR,
       _ ("Adding host %u failed with error: %s\n"),
       ntohl (msg->host_id),
       emsg);
  rh->cc (rh->cc_cls, emsg);
  GNUNET_free (rh);
}

References _, GNUNET_TESTBED_HostRegistrationHandle::c, GNUNET_TESTBED_HostRegistrationHandle::cc, GNUNET_TESTBED_HostRegistrationHandle::cc_cls, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_TESTBED_host_get_id_(), GNUNET_TESTBED_mark_host_registered_at_(), GNUNET_TESTBED_HostRegistrationHandle::host, LOG, LOG_DEBUG, msg, GNUNET_TESTBED_Controller::rh, and GNUNET_MessageHeader::size.

Here is the call graph for this function:

handle_forwarded_operation_msg()

static void handle_forwarded_operation_msg ( void *  cls, struct OperationContext *  opc, const struct GNUNET_MessageHeader *  msg  )

static

Handler for forwarded operations.

Parameters

cls	the controller handle
opc	the operation context
msg	the message

Definition at line 415 of file testbed_api.c.

{
  struct GNUNET_TESTBED_Controller *c = cls;
  struct ForwardedOperationData *fo_data;
 
  fo_data = opc->data;
  if (NULL != fo_data->cc)
    fo_data->cc (fo_data->cc_cls, msg);
  GNUNET_TESTBED_remove_opc_ (c, opc);
  GNUNET_free (fo_data);
  GNUNET_free (opc);
}

References ForwardedOperationData::cc, ForwardedOperationData::cc_cls, OperationContext::data, GNUNET_free, GNUNET_TESTBED_remove_opc_(), and msg.

Referenced by handle_link_controllers_result(), handle_op_fail_event(), handle_opsuccess(), handle_peer_conevent(), handle_peer_config(), handle_peer_create_success(), and handle_peer_event().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_opsuccess()

static void handle_opsuccess ( void *  cls, const struct GNUNET_TESTBED_GenericOperationSuccessEventMessage *  msg  )

static

Handler for GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS message from controller (testbed service)

Parameters

cls	the controller handler
msg	message received

Definition at line 439 of file testbed_api.c.

{
  struct GNUNET_TESTBED_Controller *c = cls;
  struct OperationContext *opc;
  GNUNET_TESTBED_OperationCompletionCallback op_comp_cb;
  void *op_comp_cb_cls;
  struct GNUNET_TESTBED_EventInformation event;
  uint64_t op_id;
 
  op_id = GNUNET_ntohll (msg->operation_id);
  LOG_DEBUG ("Operation %llu successful\n",
             (unsigned long long) op_id);
  if (NULL == (opc = find_opc (c, op_id)))
  {
    LOG_DEBUG ("Operation not found\n");
    return;
  }
  event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED;
  event.op = opc->op;
  event.op_cls = opc->op_cls;
  event.details.operation_finished.emsg = NULL;
  event.details.operation_finished.generic = NULL;
  op_comp_cb = NULL;
  op_comp_cb_cls = NULL;
  switch (opc->type)
  {
  case OP_FORWARDED: {
      handle_forwarded_operation_msg (c,
                                      opc,
                                      (const struct
                                       GNUNET_MessageHeader *) msg);
      return;
    }
    break;
 
  case OP_PEER_DESTROY: {
      struct GNUNET_TESTBED_Peer *peer;
 
      peer = opc->data;
      GNUNET_TESTBED_peer_deregister_ (peer);
      GNUNET_free (peer);
      opc->data = NULL;
      // PEERDESTROYDATA
    }
    break;
 
  case OP_SHUTDOWN_PEERS: {
      struct ShutdownPeersData *data;
 
      data = opc->data;
      op_comp_cb = data->cb;
      op_comp_cb_cls = data->cb_cls;
      GNUNET_free (data);
      opc->data = NULL;
      GNUNET_TESTBED_cleanup_peers_ ();
    }
    break;
 
  case OP_MANAGE_SERVICE: {
      struct ManageServiceData *data;
 
      GNUNET_assert (NULL != (data = opc->data));
      op_comp_cb = data->cb;
      op_comp_cb_cls = data->cb_cls;
      GNUNET_free (data);
      opc->data = NULL;
    }
    break;
 
  case OP_PEER_RECONFIGURE:
    break;
 
  default:
    GNUNET_assert (0);
  }
  GNUNET_TESTBED_remove_opc_ (opc->c, opc);
  opc->state = OPC_STATE_FINISHED;
  exop_insert (event.op);
  if (0 != (c->event_mask & (1L << GNUNET_TESTBED_ET_OPERATION_FINISHED)))
  {
    if (NULL != c->cc)
      c->cc (c->cc_cls, &event);
    if (GNUNET_NO == exop_check (event.op))
      return;
  }
  else
    LOG_DEBUG ("Not calling callback\n");
  if (NULL != op_comp_cb)
    op_comp_cb (op_comp_cb_cls, event.op, NULL);
  /* You could have marked the operation as done by now */
  GNUNET_break (GNUNET_NO == exop_check (event.op));
}

References OperationContext::c, GNUNET_TESTBED_Controller::cc, GNUNET_TESTBED_Controller::cc_cls, OperationContext::data, data, GNUNET_TESTBED_Controller::event_mask, exop_check(), exop_insert(), find_opc(), GNUNET_assert, GNUNET_break, GNUNET_free, GNUNET_NO, GNUNET_ntohll(), GNUNET_TESTBED_cleanup_peers_(), GNUNET_TESTBED_ET_OPERATION_FINISHED, GNUNET_TESTBED_peer_deregister_(), GNUNET_TESTBED_remove_opc_(), handle_forwarded_operation_msg(), LOG_DEBUG, msg, GNUNET_TESTBED_EventInformation::op, OperationContext::op, OperationContext::op_cls, OP_FORWARDED, OP_MANAGE_SERVICE, OP_PEER_DESTROY, OP_PEER_RECONFIGURE, OP_SHUTDOWN_PEERS, OPC_STATE_FINISHED, peer, OperationContext::state, and OperationContext::type.

Here is the call graph for this function:

handle_peer_create_success()

static void handle_peer_create_success ( void *  cls, const struct GNUNET_TESTBED_PeerCreateSuccessEventMessage *  msg  )

static

Handler for GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER_SUCCESS message from controller (testbed service)

Parameters

cls	the controller handle
msg	message received

Definition at line 543 of file testbed_api.c.

{
  struct GNUNET_TESTBED_Controller *c = cls;
  struct OperationContext *opc;
  struct PeerCreateData *data;
  struct GNUNET_TESTBED_Peer *peer;
  struct GNUNET_TESTBED_Operation *op;
  GNUNET_TESTBED_PeerCreateCallback cb;
  void *cb_cls;
  uint64_t op_id;
 
  GNUNET_assert (sizeof(struct GNUNET_TESTBED_PeerCreateSuccessEventMessage) ==
                 ntohs (msg->header.size));
  op_id = GNUNET_ntohll (msg->operation_id);
  if (NULL == (opc = find_opc (c, op_id)))
  {
    LOG_DEBUG ("Operation context for PeerCreateSuccessEvent not found\n");
    return;
  }
  if (OP_FORWARDED == opc->type)
  {
    handle_forwarded_operation_msg (c,
                                    opc,
                                    (const struct GNUNET_MessageHeader *) msg);
    return;
  }
  GNUNET_assert (OP_PEER_CREATE == opc->type);
  GNUNET_assert (NULL != opc->data);
  data = opc->data;
  GNUNET_assert (NULL != data->peer);
  peer = data->peer;
  GNUNET_assert (peer->unique_id == ntohl (msg->peer_id));
  peer->state = TESTBED_PS_CREATED;
  GNUNET_TESTBED_peer_register_ (peer);
  cb = data->cb;
  cb_cls = data->cls;
  op = opc->op;
  GNUNET_free (opc->data);
  GNUNET_TESTBED_remove_opc_ (opc->c, opc);
  opc->state = OPC_STATE_FINISHED;
  exop_insert (op);
  if (NULL != cb)
    cb (cb_cls, peer, NULL);
  /* You could have marked the operation as done by now */
  GNUNET_break (GNUNET_NO == exop_check (op));
}

References OperationContext::c, GNUNET_TESTBED_Operation::cb_cls, OperationContext::data, data, exop_check(), exop_insert(), find_opc(), GNUNET_assert, GNUNET_break, GNUNET_free, GNUNET_NO, GNUNET_ntohll(), GNUNET_TESTBED_peer_register_(), GNUNET_TESTBED_remove_opc_(), handle_forwarded_operation_msg(), LOG_DEBUG, msg, op, OperationContext::op, OP_FORWARDED, OP_PEER_CREATE, OPC_STATE_FINISHED, peer, GNUNET_MessageHeader::size, OperationContext::state, GNUNET_TESTBED_Peer::state, TESTBED_PS_CREATED, OperationContext::type, and GNUNET_TESTBED_Peer::unique_id.

Here is the call graph for this function:

handle_peer_event()

static void handle_peer_event ( void *  cls, const struct GNUNET_TESTBED_PeerEventMessage *  msg  )

static

Handler for GNUNET_MESSAGE_TYPE_TESTBED_PEER_EVENT message from controller (testbed service)

Parameters

cls	the controller handler
msg	message received

Definition at line 601 of file testbed_api.c.

{
  struct GNUNET_TESTBED_Controller *c = cls;
  struct OperationContext *opc;
  struct GNUNET_TESTBED_Peer *peer;
  struct PeerEventData *data;
  GNUNET_TESTBED_PeerChurnCallback pcc;
  void *pcc_cls;
  struct GNUNET_TESTBED_EventInformation event;
  uint64_t op_id;
  uint64_t mask;
 
  GNUNET_assert (sizeof(struct GNUNET_TESTBED_PeerEventMessage) ==
                 ntohs (msg->header.size));
  op_id = GNUNET_ntohll (msg->operation_id);
  if (NULL == (opc = find_opc (c, op_id)))
  {
    LOG_DEBUG ("Operation not found\n");
    return;
  }
  if (OP_FORWARDED == opc->type)
  {
    handle_forwarded_operation_msg (c,
                                    opc,
                                    (const struct GNUNET_MessageHeader *) msg);
    return;
  }
  GNUNET_assert ((OP_PEER_START == opc->type) || (OP_PEER_STOP == opc->type));
  data = opc->data;
  GNUNET_assert (NULL != data);
  peer = data->peer;
  GNUNET_assert (NULL != peer);
  event.type = (enum GNUNET_TESTBED_EventType) ntohl (msg->event_type);
  event.op = opc->op;
  event.op_cls = opc->op_cls;
  switch (event.type)
  {
  case GNUNET_TESTBED_ET_PEER_START:
    peer->state = TESTBED_PS_STARTED;
    event.details.peer_start.host = peer->host;
    event.details.peer_start.peer = peer;
    break;
 
  case GNUNET_TESTBED_ET_PEER_STOP:
    peer->state = TESTBED_PS_STOPPED;
    event.details.peer_stop.peer = peer;
    break;
 
  default:
    GNUNET_assert (0);  /* We should never reach this state */
  }
  pcc = data->pcc;
  pcc_cls = data->pcc_cls;
  GNUNET_free (data);
  GNUNET_TESTBED_remove_opc_ (opc->c, opc);
  opc->state = OPC_STATE_FINISHED;
  exop_insert (event.op);
  mask = 1LL << GNUNET_TESTBED_ET_PEER_START;
  mask |= 1LL << GNUNET_TESTBED_ET_PEER_STOP;
  if (0 != (mask & c->event_mask))
  {
    if (NULL != c->cc)
      c->cc (c->cc_cls, &event);
    if (GNUNET_NO == exop_check (event.op))
      return;
  }
  if (NULL != pcc)
    pcc (pcc_cls, NULL);
  /* You could have marked the operation as done by now */
  GNUNET_break (GNUNET_NO == exop_check (event.op));
}

References OperationContext::c, GNUNET_TESTBED_Controller::cc, GNUNET_TESTBED_Controller::cc_cls, OperationContext::data, data, GNUNET_TESTBED_Controller::event_mask, exop_check(), exop_insert(), find_opc(), GNUNET_assert, GNUNET_break, GNUNET_free, GNUNET_NO, GNUNET_ntohll(), GNUNET_TESTBED_ET_PEER_START, GNUNET_TESTBED_ET_PEER_STOP, GNUNET_TESTBED_remove_opc_(), handle_forwarded_operation_msg(), GNUNET_TESTBED_Peer::host, LOG_DEBUG, msg, GNUNET_TESTBED_EventInformation::op, OperationContext::op, OperationContext::op_cls, OP_FORWARDED, OP_PEER_START, OP_PEER_STOP, OPC_STATE_FINISHED, PeerEventData::pcc, PeerEventData::pcc_cls, peer, GNUNET_MessageHeader::size, OperationContext::state, GNUNET_TESTBED_Peer::state, TESTBED_PS_STARTED, TESTBED_PS_STOPPED, GNUNET_TESTBED_EventInformation::type, and OperationContext::type.

Here is the call graph for this function:

handle_peer_conevent()

static void handle_peer_conevent ( void *  cls, const struct GNUNET_TESTBED_ConnectionEventMessage *  msg  )

static

Handler for GNUNET_MESSAGE_TYPE_TESTBED_PEER_CONNECT_EVENT message from controller (testbed service)

Parameters

cls	the controller handler
msg	message received

Definition at line 682 of file testbed_api.c.

{
  struct GNUNET_TESTBED_Controller *c = cls;
  struct OperationContext *opc;
  struct OverlayConnectData *data;
  GNUNET_TESTBED_OperationCompletionCallback cb;
  void *cb_cls;
  struct GNUNET_TESTBED_EventInformation event;
  uint64_t op_id;
  uint64_t mask;
 
  op_id = GNUNET_ntohll (msg->operation_id);
  if (NULL == (opc = find_opc (c, op_id)))
  {
    LOG_DEBUG ("Operation not found\n");
    return;
  }
  if (OP_FORWARDED == opc->type)
  {
    handle_forwarded_operation_msg (c,
                                    opc,
                                    (const struct GNUNET_MessageHeader *) msg);
    return;
  }
  GNUNET_assert (OP_OVERLAY_CONNECT == opc->type);
  GNUNET_assert (NULL != (data = opc->data));
  GNUNET_assert ((ntohl (msg->peer1) == data->p1->unique_id) &&
                 (ntohl (msg->peer2) == data->p2->unique_id));
  event.type = (enum GNUNET_TESTBED_EventType) ntohl (msg->event_type);
  event.op = opc->op;
  event.op_cls = opc->op_cls;
  switch (event.type)
  {
  case GNUNET_TESTBED_ET_CONNECT:
    event.details.peer_connect.peer1 = data->p1;
    event.details.peer_connect.peer2 = data->p2;
    break;
 
  case GNUNET_TESTBED_ET_DISCONNECT:
    GNUNET_assert (0);  /* FIXME: implement */
    break;
 
  default:
    GNUNET_assert (0);  /* Should never reach here */
    break;
  }
  cb = data->cb;
  cb_cls = data->cb_cls;
  GNUNET_TESTBED_remove_opc_ (opc->c, opc);
  opc->state = OPC_STATE_FINISHED;
  exop_insert (event.op);
  mask = 1LL << GNUNET_TESTBED_ET_CONNECT;
  mask |= 1LL << GNUNET_TESTBED_ET_DISCONNECT;
  if (0 != (mask & c->event_mask))
  {
    if (NULL != c->cc)
      c->cc (c->cc_cls, &event);
    if (GNUNET_NO == exop_check (event.op))
      return;
  }
  if (NULL != cb)
    cb (cb_cls, opc->op, NULL);
  /* You could have marked the operation as done by now */
  GNUNET_break (GNUNET_NO == exop_check (event.op));
}

References OperationContext::c, OverlayConnectData::cb, OverlayConnectData::cb_cls, GNUNET_TESTBED_Controller::cc, GNUNET_TESTBED_Controller::cc_cls, OperationContext::data, data, GNUNET_TESTBED_Controller::event_mask, exop_check(), exop_insert(), find_opc(), GNUNET_assert, GNUNET_break, GNUNET_NO, GNUNET_ntohll(), GNUNET_TESTBED_ET_CONNECT, GNUNET_TESTBED_ET_DISCONNECT, GNUNET_TESTBED_remove_opc_(), handle_forwarded_operation_msg(), LOG_DEBUG, msg, GNUNET_TESTBED_EventInformation::op, OperationContext::op, OperationContext::op_cls, OP_FORWARDED, OP_OVERLAY_CONNECT, OPC_STATE_FINISHED, OperationContext::state, GNUNET_TESTBED_EventInformation::type, and OperationContext::type.

Here is the call graph for this function:

check_peer_config()

static int check_peer_config ( void *  cls, const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *  msg  )

static

Validate GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION message from controller (testbed service)

Parameters

cls	the controller handler
msg	message received

Definition at line 758 of file testbed_api.c.

{
  /* anything goes? */
  return GNUNET_OK;
}

References GNUNET_OK.

handle_peer_config()

static void handle_peer_config ( void *  cls, const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *  msg  )

static

Handler for GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION message from controller (testbed service)

Parameters

cls	the controller handler
msg	message received

Definition at line 775 of file testbed_api.c.

{
  struct GNUNET_TESTBED_Controller *c = cls;
  struct OperationContext *opc;
  struct GNUNET_TESTBED_Peer *peer;
  struct PeerInfoData *data;
  struct GNUNET_TESTBED_PeerInformation *pinfo;
  GNUNET_TESTBED_PeerInfoCallback cb;
  void *cb_cls;
  uint64_t op_id;
 
  op_id = GNUNET_ntohll (msg->operation_id);
  if (NULL == (opc = find_opc (c, op_id)))
  {
    LOG_DEBUG ("Operation not found\n");
    return;
  }
  if (OP_FORWARDED == opc->type)
  {
    handle_forwarded_operation_msg (c, opc, &msg->header);
    return;
  }
  data = opc->data;
  GNUNET_assert (NULL != data);
  peer = data->peer;
  GNUNET_assert (NULL != peer);
  GNUNET_assert (ntohl (msg->peer_id) == peer->unique_id);
  pinfo = GNUNET_new (struct GNUNET_TESTBED_PeerInformation);
  pinfo->pit = data->pit;
  cb = data->cb;
  cb_cls = data->cb_cls;
  GNUNET_assert (NULL != cb);
  GNUNET_free (data);
  opc->data = NULL;
  switch (pinfo->pit)
  {
  case GNUNET_TESTBED_PIT_IDENTITY:
    pinfo->result.id = GNUNET_new (struct GNUNET_PeerIdentity);
    GNUNET_memcpy (pinfo->result.id,
                   &msg->peer_identity,
                   sizeof(struct GNUNET_PeerIdentity));
    break;
 
  case GNUNET_TESTBED_PIT_CONFIGURATION:
    pinfo->result.cfg =   /* Freed in oprelease_peer_getinfo */
                        GNUNET_TESTBED_extract_config_ (&msg->header);
    break;
 
  case GNUNET_TESTBED_PIT_GENERIC:
    GNUNET_assert (0);  /* never reach here */
    break;
  }
  opc->data = pinfo;
  GNUNET_TESTBED_remove_opc_ (opc->c, opc);
  opc->state = OPC_STATE_FINISHED;
  cb (cb_cls, opc->op, pinfo, NULL);
  /* We dont check whether the operation is marked as done here as the
     operation contains data (cfg/identify) which will be freed at a later point
   */
}

References OperationContext::c, GNUNET_TESTBED_PeerInformation::cfg, OperationContext::data, data, find_opc(), GNUNET_assert, GNUNET_free, GNUNET_memcpy, GNUNET_new, GNUNET_ntohll(), GNUNET_TESTBED_extract_config_(), GNUNET_TESTBED_PIT_CONFIGURATION, GNUNET_TESTBED_PIT_GENERIC, GNUNET_TESTBED_PIT_IDENTITY, GNUNET_TESTBED_remove_opc_(), handle_forwarded_operation_msg(), GNUNET_TESTBED_PeerInformation::id, LOG_DEBUG, msg, OperationContext::op, OP_FORWARDED, OPC_STATE_FINISHED, peer, GNUNET_TESTBED_PeerInformation::pit, GNUNET_TESTBED_PeerInformation::result, OperationContext::state, OperationContext::type, and GNUNET_TESTBED_Peer::unique_id.

Here is the call graph for this function:

check_op_fail_event()

static int check_op_fail_event ( void *  cls, const struct GNUNET_TESTBED_OperationFailureEventMessage *  msg  )

static

Validate GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT message from controller (testbed service)

Parameters

cls	the controller handler
msg	message received

Returns

GNUNET_OK if message is well-formed

Definition at line 848 of file testbed_api.c.

{
  /* we accept anything as a valid error message */
  return GNUNET_OK;
}

References GNUNET_OK.

handle_op_fail_event()

static void handle_op_fail_event ( void *  cls, const struct GNUNET_TESTBED_OperationFailureEventMessage *  msg  )

static

Handler for GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT message from controller (testbed service)

Parameters

cls	the controller handler
msg	message received

Definition at line 865 of file testbed_api.c.

{
  struct GNUNET_TESTBED_Controller *c = cls;
  struct OperationContext *opc;
  const char *emsg;
  uint64_t op_id;
  uint64_t mask;
  struct GNUNET_TESTBED_EventInformation event;
 
  op_id = GNUNET_ntohll (msg->operation_id);
  if (NULL == (opc = find_opc (c, op_id)))
  {
    LOG_DEBUG ("Operation not found\n");
    return;
  }
  if (OP_FORWARDED == opc->type)
  {
    handle_forwarded_operation_msg (c,
                                    opc,
                                    (const struct GNUNET_MessageHeader *) msg);
    return;
  }
  GNUNET_TESTBED_remove_opc_ (opc->c, opc);
  opc->state = OPC_STATE_FINISHED;
  emsg = GNUNET_TESTBED_parse_error_string_ (msg);
  if (NULL == emsg)
    emsg = "Unknown error";
  if (OP_PEER_INFO == opc->type)
  {
    struct PeerInfoData *data;
 
    data = opc->data;
    if (NULL != data->cb)
      data->cb (data->cb_cls, opc->op, NULL, emsg);
    GNUNET_free (data);
    return;   /* We do not call controller callback for peer info */
  }
  event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED;
  event.op = opc->op;
  event.op_cls = opc->op_cls;
  event.details.operation_finished.emsg = emsg;
  event.details.operation_finished.generic = NULL;
  mask = (1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED);
  if ((0 != (mask & c->event_mask)) && (NULL != c->cc))
  {
    exop_insert (event.op);
    c->cc (c->cc_cls, &event);
    if (GNUNET_NO == exop_check (event.op))
      return;
  }
  switch (opc->type)
  {
  case OP_PEER_CREATE: {
      struct PeerCreateData *data;
 
      data = opc->data;
      GNUNET_free (data->peer);
      if (NULL != data->cb)
        data->cb (data->cls, NULL, emsg);
      GNUNET_free (data);
    }
    break;
 
  case OP_PEER_START:
  case OP_PEER_STOP: {
      struct PeerEventData *data;
 
      data = opc->data;
      if (NULL != data->pcc)
        data->pcc (data->pcc_cls, emsg);
      GNUNET_free (data);
    }
    break;
 
  case OP_PEER_DESTROY:
    break;
 
  case OP_PEER_INFO:
    GNUNET_assert (0);
 
  case OP_OVERLAY_CONNECT: {
      struct OverlayConnectData *data;
 
      data = opc->data;
      GNUNET_TESTBED_operation_mark_failed (opc->op);
      if (NULL != data->cb)
        data->cb (data->cb_cls, opc->op, emsg);
    }
    break;
 
  case OP_FORWARDED:
    GNUNET_assert (0);
 
  case OP_LINK_CONTROLLERS:   /* No secondary callback */
    break;
 
  case OP_SHUTDOWN_PEERS: {
      struct ShutdownPeersData *data;
 
      data = opc->data;
      GNUNET_free (data); /* FIXME: Decide whether we call data->op_cb */
      opc->data = NULL;
    }
    break;
 
  case OP_MANAGE_SERVICE: {
      struct ManageServiceData *data = opc->data;
      GNUNET_TESTBED_OperationCompletionCallback cb;
      void *cb_cls;
 
      GNUNET_assert (NULL != data);
      cb = data->cb;
      cb_cls = data->cb_cls;
      GNUNET_free (data);
      opc->data = NULL;
      exop_insert (event.op);
      if (NULL != cb)
        cb (cb_cls, opc->op, emsg);
      /* You could have marked the operation as done by now */
      GNUNET_break (GNUNET_NO == exop_check (event.op));
    }
    break;
 
  default:
    GNUNET_break (0);
  }
}

References OperationContext::c, ManageServiceData::cb, ManageServiceData::cb_cls, GNUNET_TESTBED_Controller::cc, GNUNET_TESTBED_Controller::cc_cls, OperationContext::data, data, GNUNET_TESTBED_EventInformation::emsg, GNUNET_TESTBED_Controller::event_mask, exop_check(), exop_insert(), find_opc(), GNUNET_assert, GNUNET_break, GNUNET_free, GNUNET_NO, GNUNET_ntohll(), GNUNET_TESTBED_ET_OPERATION_FINISHED, GNUNET_TESTBED_operation_mark_failed(), GNUNET_TESTBED_parse_error_string_(), GNUNET_TESTBED_remove_opc_(), handle_forwarded_operation_msg(), LOG_DEBUG, msg, GNUNET_TESTBED_EventInformation::op, OperationContext::op, OperationContext::op_cls, OP_FORWARDED, OP_LINK_CONTROLLERS, OP_MANAGE_SERVICE, OP_OVERLAY_CONNECT, OP_PEER_CREATE, OP_PEER_DESTROY, OP_PEER_INFO, OP_PEER_START, OP_PEER_STOP, OP_SHUTDOWN_PEERS, OPC_STATE_FINISHED, OperationContext::state, and OperationContext::type.

Here is the call graph for this function:

GNUNET_TESTBED_generate_slavegetconfig_msg_()

static struct GNUNET_TESTBED_SlaveGetConfigurationMessage* GNUNET_TESTBED_generate_slavegetconfig_msg_ ( uint64_t  op_id, uint32_t  slave_id  )

static

Function to build GET_SLAVE_CONFIG message.

Parameters

op_id	the id this message should contain in its operation id field
slave_id	the id this message should contain in its slave id field

Returns

newly allocated SlaveGetConfigurationMessage

Definition at line 1004 of file testbed_api.c.

{
  struct GNUNET_TESTBED_SlaveGetConfigurationMessage *msg;
  uint16_t msize;
 
  msize = sizeof(struct GNUNET_TESTBED_SlaveGetConfigurationMessage);
  msg = GNUNET_malloc (msize);
  msg->header.size = htons (msize);
  msg->header.type =
    htons (GNUNET_MESSAGE_TYPE_TESTBED_GET_SLAVE_CONFIGURATION);
  msg->operation_id = GNUNET_htonll (op_id);
  msg->slave_id = htonl (slave_id);
  return msg;
}

References GNUNET_htonll(), GNUNET_malloc, GNUNET_MESSAGE_TYPE_TESTBED_GET_SLAVE_CONFIGURATION, msg, GNUNET_MessageHeader::size, GNUNET_TESTBED_SlaveGetConfigurationMessage::slave_id, and GNUNET_MessageHeader::type.

Referenced by opstart_get_slave_config().

Here is the call graph for this function:

Here is the caller graph for this function:

check_slave_config()

static int check_slave_config ( void *  cls, const struct GNUNET_TESTBED_SlaveConfiguration *  msg  )

static

Validate #GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_INFORMATION message from controller (testbed service)

Parameters

c	the controller handler
msg	message received

Definition at line 1028 of file testbed_api.c.

{
  /* anything goes? */
  return GNUNET_OK;
}

References GNUNET_OK.

handle_slave_config()

static void handle_slave_config ( void *  cls, const struct GNUNET_TESTBED_SlaveConfiguration *  msg  )

static

Handler for GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION message from controller (testbed service)

Parameters

cls	the controller handler
msg	message received

Definition at line 1044 of file testbed_api.c.

{
  struct GNUNET_TESTBED_Controller *c = cls;
  struct OperationContext *opc;
  uint64_t op_id;
  uint64_t mask;
  struct GNUNET_TESTBED_EventInformation event;
 
  op_id = GNUNET_ntohll (msg->operation_id);
  if (NULL == (opc = find_opc (c, op_id)))
  {
    LOG_DEBUG ("Operation not found\n");
    return;
  }
  if (OP_GET_SLAVE_CONFIG != opc->type)
  {
    GNUNET_break (0);
    return;
  }
  opc->state = OPC_STATE_FINISHED;
  GNUNET_TESTBED_remove_opc_ (opc->c, opc);
  mask = 1LL << GNUNET_TESTBED_ET_OPERATION_FINISHED;
  if ((0 != (mask & c->event_mask)) && (NULL != c->cc))
  {
    opc->data = GNUNET_TESTBED_extract_config_ (&msg->header);
    event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED;
    event.op = opc->op;
    event.op_cls = opc->op_cls;
    event.details.operation_finished.generic = opc->data;
    event.details.operation_finished.emsg = NULL;
    c->cc (c->cc_cls, &event);
  }
}

References OperationContext::c, GNUNET_TESTBED_Controller::cc, GNUNET_TESTBED_Controller::cc_cls, OperationContext::data, GNUNET_TESTBED_Controller::event_mask, find_opc(), GNUNET_break, GNUNET_ntohll(), GNUNET_TESTBED_ET_OPERATION_FINISHED, GNUNET_TESTBED_extract_config_(), GNUNET_TESTBED_remove_opc_(), LOG_DEBUG, msg, OperationContext::op, OperationContext::op_cls, OP_GET_SLAVE_CONFIG, OPC_STATE_FINISHED, OperationContext::state, and OperationContext::type.

Here is the call graph for this function:

check_link_controllers_result()

static int check_link_controllers_result ( void *  cls, const struct GNUNET_TESTBED_ControllerLinkResponse *  msg  )

static

Check GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT message from controller (testbed service)

Parameters

c	the controller handler
msg	message received

Returns

GNUNET_OK if msg is well-formed

Definition at line 1089 of file testbed_api.c.

{
  /* actual check to be implemented */
  return GNUNET_OK;
}

References GNUNET_OK.

handle_link_controllers_result()

static void handle_link_controllers_result ( void *  cls, const struct GNUNET_TESTBED_ControllerLinkResponse *  msg  )

static

Handler for GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS_RESULT message from controller (testbed service)

Parameters

cls	the controller handler
msg	message received

Definition at line 1106 of file testbed_api.c.

{
  struct GNUNET_TESTBED_Controller *c = cls;
  struct OperationContext *opc;
  struct ControllerLinkData *data;
  struct GNUNET_CONFIGURATION_Handle *cfg;
  struct GNUNET_TESTBED_Host *host;
  char *emsg;
  uint64_t op_id;
  struct GNUNET_TESTBED_EventInformation event;
 
  op_id = GNUNET_ntohll (msg->operation_id);
  if (NULL == (opc = find_opc (c, op_id)))
  {
    LOG_DEBUG ("Operation not found\n");
    return;
  }
  if (OP_FORWARDED == opc->type)
  {
    handle_forwarded_operation_msg (c,
                                    opc,
                                    (const struct GNUNET_MessageHeader *) msg);
    return;
  }
  if (OP_LINK_CONTROLLERS != opc->type)
  {
    GNUNET_break (0);
    return;
  }
  GNUNET_assert (NULL != (data = opc->data));
  host = GNUNET_TESTBED_host_lookup_by_id_ (data->host_id);
  GNUNET_assert (NULL != host);
  GNUNET_free (data);
  opc->data = NULL;
  opc->state = OPC_STATE_FINISHED;
  GNUNET_TESTBED_remove_opc_ (opc->c, opc);
  event.type = GNUNET_TESTBED_ET_OPERATION_FINISHED;
  event.op = opc->op;
  event.op_cls = opc->op_cls;
  event.details.operation_finished.emsg = NULL;
  event.details.operation_finished.generic = NULL;
  emsg = NULL;
  cfg = NULL;
  if (GNUNET_NO == ntohs (msg->success))
  {
    emsg =
      GNUNET_malloc (ntohs (msg->header.size)
                     - sizeof(struct GNUNET_TESTBED_ControllerLinkResponse)
                     + 1);
    GNUNET_memcpy (emsg,
                   &msg[1],
                   ntohs (msg->header.size)
                   - sizeof(struct GNUNET_TESTBED_ControllerLinkResponse));
    event.details.operation_finished.emsg = emsg;
  }
  else
  {
    if (0 != ntohs (msg->config_size))
    {
      cfg = GNUNET_TESTBED_extract_config_ (
        (const struct GNUNET_MessageHeader *) msg);
      GNUNET_assert (NULL != cfg);
      GNUNET_TESTBED_host_replace_cfg_ (host, cfg);
    }
  }
  if (0 != (c->event_mask & (1L << GNUNET_TESTBED_ET_OPERATION_FINISHED)))
  {
    if (NULL != c->cc)
      c->cc (c->cc_cls, &event);
  }
  else
    LOG_DEBUG ("Not calling callback\n");
  if (NULL != cfg)
    GNUNET_CONFIGURATION_destroy (cfg);
  GNUNET_free (emsg);
}

References OperationContext::c, GNUNET_TESTBED_Controller::cc, GNUNET_TESTBED_Controller::cc_cls, cfg, OperationContext::data, data, GNUNET_TESTBED_EventInformation::emsg, GNUNET_TESTBED_Controller::event_mask, find_opc(), GNUNET_assert, GNUNET_break, GNUNET_CONFIGURATION_destroy(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_ntohll(), GNUNET_TESTBED_ET_OPERATION_FINISHED, GNUNET_TESTBED_extract_config_(), GNUNET_TESTBED_host_lookup_by_id_(), GNUNET_TESTBED_host_replace_cfg_(), GNUNET_TESTBED_remove_opc_(), handle_forwarded_operation_msg(), GNUNET_TESTBED_EventInformation::host, LOG_DEBUG, msg, OperationContext::op, OperationContext::op_cls, OP_FORWARDED, OP_LINK_CONTROLLERS, OPC_STATE_FINISHED, GNUNET_MessageHeader::size, OperationContext::state, and OperationContext::type.

Here is the call graph for this function:

check_barrier_status()

static int check_barrier_status ( void *  cls, const struct GNUNET_TESTBED_BarrierStatusMsg *  msg  )

static

Validate GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS message.

Parameters

cls	the controller handle to determine the connection this message belongs to
msg	the barrier status message

Returns

GNUNET_OK if the message is valid; GNUNET_SYSERR to tear it down signalling an error (message malformed)

Definition at line 1196 of file testbed_api.c.

{
  uint16_t msize;
  uint16_t name_len;
  int status;
  const char *name;
  size_t emsg_len;
 
  msize = ntohs (msg->header.size);
  name = msg->data;
  name_len = ntohs (msg->name_len);
 
  if (sizeof(struct GNUNET_TESTBED_BarrierStatusMsg) + name_len + 1 > msize)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if ('\0' != name[name_len])
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  status = ntohs (msg->status);
  if (GNUNET_TESTBED_BARRIERSTATUS_ERROR == status)
  {
    emsg_len = msize - (sizeof(struct GNUNET_TESTBED_BarrierStatusMsg)
                        + name_len + 1); /* +1!? */
    if (0 == emsg_len)
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, GNUNET_TESTBED_BARRIERSTATUS_ERROR, msg, name, GNUNET_TESTBED_BarrierStatusMsg::name_len, GNUNET_MessageHeader::size, and status.

handle_barrier_status()

static void handle_barrier_status ( void *  cls, const struct GNUNET_TESTBED_BarrierStatusMsg *  msg  )

static

Handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS messages.

Parameters

cls	the controller handle to determine the connection this message belongs to
msg	the barrier status message

Do not remove the barrier if we did not echo the status back; this is required at the chained testbed controller setup to ensure the only the test-driver echos the status and the controller hierarchy properly propagates the status.

Definition at line 1242 of file testbed_api.c.

{
  struct GNUNET_TESTBED_Controller *c = cls;
  struct GNUNET_TESTBED_Barrier *barrier;
  char *emsg;
  const char *name;
  struct GNUNET_HashCode key;
  size_t emsg_len;
  int status;
  uint16_t msize;
  uint16_t name_len;
 
  emsg = NULL;
  barrier = NULL;
  msize = ntohs (msg->header.size);
  if (msize <= sizeof(struct GNUNET_TESTBED_BarrierStatusMsg))
  {
    GNUNET_break_op (0);
    goto cleanup;
  }
  name = msg->data;
  name_len = ntohs (msg->name_len);
  if (name_len >= // name_len is strlen(barrier_name)
      (msize - ((sizeof msg->header) + sizeof(msg->status))))
  {
    GNUNET_break_op (0);
    goto cleanup;
  }
  if ('\0' != name[name_len])
  {
    GNUNET_break_op (0);
    goto cleanup;
  }
  LOG_DEBUG ("Received BARRIER_STATUS msg\n");
  status = ntohs (msg->status);
  if (GNUNET_TESTBED_BARRIERSTATUS_ERROR == status)
  {
    status = -1;
    // unlike name_len, emsg_len includes the trailing zero
    emsg_len = msize - (sizeof(struct GNUNET_TESTBED_BarrierStatusMsg)
                        + (name_len + 1));
    if (0 == emsg_len)
    {
      GNUNET_break_op (0);
      goto cleanup;
    }
    if ('\0' != (msg->data[(name_len + 1) + (emsg_len - 1)]))
    {
      GNUNET_break_op (0);
      goto cleanup;
    }
    emsg = GNUNET_malloc (emsg_len);
    GNUNET_memcpy (emsg, msg->data + name_len + 1, emsg_len);
  }
  if (NULL == c->barrier_map)
  {
    GNUNET_break_op (0);
    goto cleanup;
  }
  GNUNET_CRYPTO_hash (name, name_len, &key);
  barrier = GNUNET_CONTAINER_multihashmap_get (c->barrier_map, &key);
  if (NULL == barrier)
  {
    GNUNET_break_op (0);
    goto cleanup;
  }
  GNUNET_assert (NULL != barrier->cb);
  if ((GNUNET_YES == barrier->echo) &&
      (GNUNET_TESTBED_BARRIERSTATUS_CROSSED == status))
    GNUNET_TESTBED_queue_message_ (c, GNUNET_copy_message (&msg->header));
  barrier->cb (barrier->cls, name, barrier, status, emsg);
  if (GNUNET_TESTBED_BARRIERSTATUS_INITIALISED == status)
    return; /* just initialised; skip cleanup */
 
cleanup:
  GNUNET_free (emsg);if ((NULL != barrier) && (GNUNET_YES == barrier->echo))
    GNUNET_TESTBED_barrier_remove_ (barrier);
}

References GNUNET_TESTBED_Controller::barrier_map, GNUNET_TESTBED_Barrier::cb, cleanup(), GNUNET_TESTBED_Barrier::cls, GNUNET_TESTBED_Barrier::echo, GNUNET_assert, GNUNET_break_op, GNUNET_CONTAINER_multihashmap_get(), GNUNET_copy_message(), GNUNET_CRYPTO_hash(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_TESTBED_barrier_remove_(), GNUNET_TESTBED_BARRIERSTATUS_CROSSED, GNUNET_TESTBED_BARRIERSTATUS_ERROR, GNUNET_TESTBED_BARRIERSTATUS_INITIALISED, GNUNET_TESTBED_queue_message_(), GNUNET_YES, key, LOG_DEBUG, msg, name, GNUNET_TESTBED_BarrierStatusMsg::name_len, GNUNET_MessageHeader::size, and status.

Here is the call graph for this function:

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

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_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:

opstart_link_controllers()

static void opstart_link_controllers ( void *  cls )

static

Function to call to start a link-controllers type operation once all queues the operation is part of declare that the operation can be activated.

Parameters

cls	the closure from GNUNET_TESTBED_operation_create_()

Definition at line 1422 of file testbed_api.c.

{
  struct OperationContext *opc = cls;
  struct ControllerLinkData *data;
  struct GNUNET_TESTBED_ControllerLinkRequest *msg;
 
  GNUNET_assert (NULL != opc->data);
  data = opc->data;
  msg = data->msg;
  data->msg = NULL;
  opc->state = OPC_STATE_STARTED;
  GNUNET_TESTBED_insert_opc_ (opc->c, opc);
  GNUNET_TESTBED_queue_message_ (opc->c, &msg->header);
}

References OperationContext::c, OperationContext::data, data, GNUNET_assert, GNUNET_TESTBED_insert_opc_(), GNUNET_TESTBED_queue_message_(), msg, OPC_STATE_STARTED, and OperationContext::state.

Referenced by GNUNET_TESTBED_controller_link().

Here is the call graph for this function:

Here is the caller graph for this function:

oprelease_link_controllers()

static void oprelease_link_controllers ( void *  cls )

static

Callback which will be called when link-controllers type operation is released.

Parameters

cls	the closure from GNUNET_TESTBED_operation_create_()

Definition at line 1444 of file testbed_api.c.

{
  struct OperationContext *opc = cls;
  struct ControllerLinkData *data;
 
  data = opc->data;
  switch (opc->state)
  {
  case OPC_STATE_INIT:
    GNUNET_free (data->msg);
    break;
 
  case OPC_STATE_STARTED:
    GNUNET_TESTBED_remove_opc_ (opc->c, opc);
    break;
 
  case OPC_STATE_FINISHED:
    break;
  }
  GNUNET_free (data);
  GNUNET_free (opc);
}

References OperationContext::c, OperationContext::data, data, GNUNET_free, GNUNET_TESTBED_remove_opc_(), OPC_STATE_FINISHED, OPC_STATE_INIT, OPC_STATE_STARTED, and OperationContext::state.

Referenced by GNUNET_TESTBED_controller_link().

Here is the call graph for this function:

Here is the caller graph for this function:

opstart_get_slave_config()

static void opstart_get_slave_config ( void *  cls )

static

Function to be called when get slave config operation is ready.

Parameters

cls	the OperationContext of type OP_GET_SLAVE_CONFIG

Definition at line 1474 of file testbed_api.c.

{
  struct OperationContext *opc = cls;
  struct GetSlaveConfigData *data = opc->data;
  struct GNUNET_TESTBED_SlaveGetConfigurationMessage *msg;
 
  GNUNET_assert (NULL != data);
  msg = GNUNET_TESTBED_generate_slavegetconfig_msg_ (opc->id, data->slave_id);
  GNUNET_free (opc->data);
  data = NULL;
  opc->data = NULL;
  GNUNET_TESTBED_insert_opc_ (opc->c, opc);
  GNUNET_TESTBED_queue_message_ (opc->c, &msg->header);
  opc->state = OPC_STATE_STARTED;
}

References OperationContext::c, OperationContext::data, data, GNUNET_assert, GNUNET_free, GNUNET_TESTBED_generate_slavegetconfig_msg_(), GNUNET_TESTBED_insert_opc_(), GNUNET_TESTBED_queue_message_(), OperationContext::id, msg, OPC_STATE_STARTED, and OperationContext::state.

Referenced by GNUNET_TESTBED_get_slave_config_().

Here is the call graph for this function:

Here is the caller graph for this function:

oprelease_get_slave_config()

static void oprelease_get_slave_config ( void *  cls )

static

Function to be called when get slave config operation is cancelled or finished.

Parameters

cls	the OperationContext of type OP_GET_SLAVE_CONFIG

Definition at line 1497 of file testbed_api.c.

{
  struct OperationContext *opc = cls;
 
  switch (opc->state)
  {
  case OPC_STATE_INIT:
    GNUNET_free (opc->data);
    break;
 
  case OPC_STATE_STARTED:
    GNUNET_TESTBED_remove_opc_ (opc->c, opc);
    break;
 
  case OPC_STATE_FINISHED:
    if (NULL != opc->data)
      GNUNET_CONFIGURATION_destroy (opc->data);
    break;
  }
  GNUNET_free (opc);
}

References OperationContext::c, OperationContext::data, GNUNET_CONFIGURATION_destroy(), GNUNET_free, GNUNET_TESTBED_remove_opc_(), OPC_STATE_FINISHED, OPC_STATE_INIT, OPC_STATE_STARTED, and OperationContext::state.

Referenced by GNUNET_TESTBED_get_slave_config_().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_error_handler()

static void mq_error_handler ( void *  cls, enum GNUNET_MQ_Error  error  )

static

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters

cls	closure, a struct GNUNET_TESTBED_Controller *
error	error code

Definition at line 1529 of file testbed_api.c.

{
  /* struct GNUNET_TESTBED_Controller *c = cls; */
 
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Encountered MQ error: %d\n", error);
  /* now what? */
  GNUNET_SCHEDULER_shutdown ();  /* seems most reasonable */
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_log, and GNUNET_SCHEDULER_shutdown().

Referenced by GNUNET_TESTBED_controller_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

opc_free_iterator()

static int opc_free_iterator ( void *  cls, uint32_t  key, void *  value  )

static

Iterator to free opc map entries.

Parameters

cls	closure
key	current key code
value	value in the hash map

Returns

GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 1699 of file testbed_api.c.

{
  struct GNUNET_CONTAINER_MultiHashMap32 *map = cls;
  struct OperationContext *opc = value;
 
  GNUNET_assert (NULL != opc);
  GNUNET_break (0);
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multihashmap32_remove (map, key, value));
  GNUNET_free (opc);
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap32_remove(), GNUNET_free, GNUNET_YES, key, map, and value.

Referenced by GNUNET_TESTBED_controller_disconnect().

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_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_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 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_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_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:

opstart_shutdown_peers()

static void opstart_shutdown_peers ( void *  cls )

static

Function called when a shutdown peers operation is ready.

Parameters

cls	the closure from GNUNET_TESTBED_operation_create_()

Definition at line 2195 of file testbed_api.c.

{
  struct OperationContext *opc = cls;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TESTBED_ShutdownPeersMessage *msg;
 
  opc->state = OPC_STATE_STARTED;
  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS);
  msg->operation_id = GNUNET_htonll (opc->id);
  GNUNET_TESTBED_insert_opc_ (opc->c, opc);
  GNUNET_MQ_send (opc->c->mq, env);
}

References OperationContext::c, env, GNUNET_htonll(), GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_TESTBED_insert_opc_(), OperationContext::id, GNUNET_TESTBED_Controller::mq, msg, OPC_STATE_STARTED, and OperationContext::state.

Referenced by GNUNET_TESTBED_shutdown_peers().

Here is the call graph for this function:

Here is the caller graph for this function:

oprelease_shutdown_peers()

static void oprelease_shutdown_peers ( void *  cls )

static

Callback which will be called when shutdown peers operation is released.

Parameters

cls	the closure from GNUNET_TESTBED_operation_create_()

Definition at line 2215 of file testbed_api.c.

{
  struct OperationContext *opc = cls;
 
  switch (opc->state)
  {
  case OPC_STATE_STARTED:
    GNUNET_TESTBED_remove_opc_ (opc->c, opc);
 
  /* no break; continue */
  case OPC_STATE_INIT:
    GNUNET_free (opc->data);
    break;
 
  case OPC_STATE_FINISHED:
    break;
  }
  GNUNET_free (opc);
}

References OperationContext::c, OperationContext::data, GNUNET_free, GNUNET_TESTBED_remove_opc_(), OPC_STATE_FINISHED, OPC_STATE_INIT, OPC_STATE_STARTED, and OperationContext::state.

Referenced by GNUNET_TESTBED_shutdown_peers().

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:

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:

Variable Documentation

exop_head

struct ExpireOperationEntry* exop_head

static

DLL head for list of operations marked for expiry.

Definition at line 155 of file testbed_api.c.

Referenced by exop_check(), and exop_insert().

exop_tail

struct ExpireOperationEntry* exop_tail

static

DLL tail for list of operation marked for expiry.

Definition at line 160 of file testbed_api.c.

Referenced by exop_check(), and exop_insert().