gnunet-service-testbed_barriers.c File Reference

barrier handling at the testbed controller More...

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

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

Go to the source code of this file.

Data Structures
struct	ClientCtx
	Context to be associated with each client. More...
struct	WBarrier
	Wrapper around Barrier handle. More...
struct	Barrier
	Barrier. More...

Macros
#define	MESSAGE_SEND_TIMEOUT(s)    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, s)
	timeout for outgoing message transmissions in seconds More...
#define	LOCAL_QUORUM_REACHED(barrier)    ((barrier->quorum * GST_num_local_peers) <= (barrier->nreached * 100))
	Test to see if local peers have reached the required quorum of a barrier. More...
#define	LOG(kind, ...)    GNUNET_log_from (kind, "testbed-barriers", __VA_ARGS__)
	Logging shorthand. More...

Functions
static void	remove_barrier (struct Barrier *barrier)
	Function to remove a barrier from the barrier map and cleanup resources occupied by a barrier. More...
static void	cancel_wrappers (struct Barrier *barrier)
	Cancels all subcontroller barrier handles. More...
static void	send_client_status_msg (struct GNUNET_SERVICE_Client *client, const char *name, enum GNUNET_TESTBED_BarrierStatus status, const char *emsg)
	Send a status message about a barrier to the given client. More...
static void	send_barrier_status_msg (struct Barrier *barrier, const char *emsg)
	Sends a barrier failed message. More...
static int	check_barrier_wait (void *cls, const struct GNUNET_TESTBED_BarrierWait *msg)
	Check GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT messages. More...
static void	handle_barrier_wait (void *cls, const struct GNUNET_TESTBED_BarrierWait *msg)
	Message handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT messages. More...
static void *	connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
	Function called when a client connects to the testbed-barrier service. More...
static void	disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
	Functions with this signature are called whenever a client is disconnected on the network level. More...
void	GST_barriers_init (struct GNUNET_CONFIGURATION_Handle *cfg)
	Function to initialise barriers component. More...
static int	barrier_destroy_iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterator over hash map entries. More...
void	GST_barriers_destroy ()
	Function to stop the barrier service. More...
static void	wbarrier_status_cb (void *cls, const char *name, struct GNUNET_TESTBED_Barrier *b_, enum GNUNET_TESTBED_BarrierStatus status, const char *emsg)
	Functions of this type are to be given as callback argument to GNUNET_TESTBED_barrier_init(). More...
static void	fwd_tout_barrier_init (void *cls)
	Function called upon timeout while waiting for a response from the subcontrollers to barrier init message. More...
int	check_barrier_init (void *cls, const struct GNUNET_TESTBED_BarrierInit *msg)
	Check GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT messages. More...
void	handle_barrier_init (void *cls, const struct GNUNET_TESTBED_BarrierInit *msg)
	Message handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT messages. More...
int	check_barrier_cancel (void *cls, const struct GNUNET_TESTBED_BarrierCancel *msg)
	Check GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL messages. More...
void	handle_barrier_cancel (void *cls, const struct GNUNET_TESTBED_BarrierCancel *msg)
	Message handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL messages. More...
int	check_barrier_status (void *cls, const struct GNUNET_TESTBED_BarrierStatusMsg *msg)
	Check GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS messages. More...
void	handle_barrier_status (void *cls, const struct GNUNET_TESTBED_BarrierStatusMsg *msg)
	Message handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS messages. More...

Variables
static struct GNUNET_CONTAINER_MultiHashMap *	barrier_map
	Hashtable handle for storing initialised barriers. More...
static struct GNUNET_SERVICE_Handle *	ctx
	Service context. More...

Detailed Description

barrier handling at the testbed controller

Author

Sree Harsha Totakura sreeh.nosp@m.arsh.nosp@m.a@tot.nosp@m.akur.nosp@m.a.in

Definition in file gnunet-service-testbed_barriers.c.

Macro Definition Documentation

MESSAGE_SEND_TIMEOUT

#define MESSAGE_SEND_TIMEOUT

(

s

)

GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, s)

timeout for outgoing message transmissions in seconds

Definition at line 36 of file gnunet-service-testbed_barriers.c.

LOCAL_QUORUM_REACHED

#define LOCAL_QUORUM_REACHED

(

barrier

)

((barrier->quorum * GST_num_local_peers) <= (barrier->nreached * 100))

Test to see if local peers have reached the required quorum of a barrier.

Definition at line 43 of file gnunet-service-testbed_barriers.c.

LOG

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

Logging shorthand.

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

Function Documentation

remove_barrier()

static void remove_barrier ( struct Barrier *  barrier )

static

Function to remove a barrier from the barrier map and cleanup resources occupied by a barrier.

Parameters

barrier

the barrier handle

Definition at line 228 of file gnunet-service-testbed_barriers.c.

{
  struct ClientCtx *ctx;
 
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multihashmap_remove (barrier_map,
                                                       &barrier->hash,
                                                       barrier));
  while (NULL != (ctx = barrier->head))
  {
    GNUNET_CONTAINER_DLL_remove (barrier->head,
                                 barrier->tail,
                                 ctx);
    ctx->barrier = NULL;
  }
  GNUNET_free (barrier->name);
  GNUNET_free (barrier);
}

References ClientCtx::barrier, barrier_map, ctx, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_free, GNUNET_YES, Barrier::hash, Barrier::head, Barrier::name, and Barrier::tail.

Referenced by barrier_destroy_iterator(), fwd_tout_barrier_init(), and handle_barrier_cancel().

Here is the call graph for this function:

Here is the caller graph for this function:

cancel_wrappers()

static void cancel_wrappers ( struct Barrier *  barrier )

static

Cancels all subcontroller barrier handles.

Parameters

barrier

the local barrier

Definition at line 254 of file gnunet-service-testbed_barriers.c.

{
  struct WBarrier *wrapper;
 
  while (NULL != (wrapper = barrier->whead))
  {
    GNUNET_TESTBED_barrier_cancel (wrapper->hbarrier);
    GNUNET_CONTAINER_DLL_remove (barrier->whead,
                                 barrier->wtail,
                                 wrapper);
    GNUNET_free (wrapper);
  }
}

References WBarrier::barrier, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_TESTBED_barrier_cancel(), WBarrier::hbarrier, Barrier::whead, and Barrier::wtail.

Referenced by barrier_destroy_iterator(), fwd_tout_barrier_init(), handle_barrier_cancel(), and wbarrier_status_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

send_client_status_msg()

static void send_client_status_msg ( struct GNUNET_SERVICE_Client *  client, const char *  name, enum GNUNET_TESTBED_BarrierStatus  status, const char *  emsg  )

static

Send a status message about a barrier to the given client.

Parameters

client	the client to send the message to
name	the barrier name
status	the status of the barrier
emsg	the error message; should be non-NULL for status=GNUNET_TESTBED_BARRIERSTATUS_ERROR

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

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_TESTBED_BarrierStatusMsg *msg;
  size_t name_len;
  size_t err_len;
 
  GNUNET_assert ((NULL == emsg) ||
                 (GNUNET_TESTBED_BARRIERSTATUS_ERROR == status));
  name_len = strlen (name) + 1;
  err_len = ((NULL == emsg) ? 0 : (strlen (emsg) + 1));
  env = GNUNET_MQ_msg_extra (msg,
                             name_len + err_len,
                             GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS);
  msg->status = htons (status);
  msg->name_len = htons ((uint16_t) name_len - 1);
  GNUNET_memcpy (msg->data,
                 name,
                 name_len);
  GNUNET_memcpy (msg->data + name_len,
                 emsg,
                 err_len);
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
                  env);
}

References env, GNUNET_assert, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_SERVICE_client_get_mq(), GNUNET_TESTBED_BARRIERSTATUS_ERROR, msg, name, GNUNET_TESTBED_BarrierStatusMsg::name_len, and status.

Referenced by handle_barrier_init(), and send_barrier_status_msg().

Here is the call graph for this function:

Here is the caller graph for this function:

send_barrier_status_msg()

static void send_barrier_status_msg ( struct Barrier *  barrier, const char *  emsg  )

static

Sends a barrier failed message.

Parameters

barrier	the corresponding barrier
emsg	the error message; should be non-NULL for status=GNUNET_TESTBED_BARRIERSTATUS_ERROR

Definition at line 317 of file gnunet-service-testbed_barriers.c.

{
  GNUNET_assert (0 != barrier->status);
  send_client_status_msg (barrier->mc,
                          barrier->name,
                          barrier->status,
                          emsg);
}

References GNUNET_assert, Barrier::mc, Barrier::name, send_client_status_msg(), and Barrier::status.

Referenced by fwd_tout_barrier_init(), handle_barrier_init(), handle_barrier_wait(), and wbarrier_status_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

check_barrier_wait()

static int check_barrier_wait ( void *  cls, const struct GNUNET_TESTBED_BarrierWait *  msg  )

static

Check GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT messages.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 335 of file gnunet-service-testbed_barriers.c.

{
  return GNUNET_OK; /* always well-formed */
}

References GNUNET_OK.

handle_barrier_wait()

static void handle_barrier_wait ( void *  cls, const struct GNUNET_TESTBED_BarrierWait *  msg  )

static

Message handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT messages.

This message should come from peers or a shared helper service using the testbed-barrier client API (

See also

gnunet_testbed_barrier_service.h)

This handler is queued in the main service and will handle the messages sent either from the testbed driver or from a high level controller

Parameters

cls	identification of the client
msg	the actual message

Definition at line 354 of file gnunet-service-testbed_barriers.c.

{
  struct ClientCtx *client_ctx = cls;
  struct Barrier *barrier;
  char *name;
  struct GNUNET_HashCode key;
  size_t name_len;
  uint16_t msize;
 
  msize = ntohs (msg->header.size);
  if (NULL == barrier_map)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (client_ctx->client);
    return;
  }
  name_len = msize - sizeof(struct GNUNET_TESTBED_BarrierWait);
  name = GNUNET_malloc (name_len + 1);
  name[name_len] = '\0';
  GNUNET_memcpy (name,
                 msg->name,
                 name_len);
  LOG_DEBUG ("Received BARRIER_WAIT for barrier `%s'\n",
             name);
  GNUNET_CRYPTO_hash (name,
                      name_len,
                      &key);
  GNUNET_free (name);
  if (NULL == (barrier = GNUNET_CONTAINER_multihashmap_get (barrier_map, &key)))
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (client_ctx->client);
    return;
  }
  if (NULL != client_ctx->barrier)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (client_ctx->client);
    return;
  }
  client_ctx->barrier = barrier;
  GNUNET_CONTAINER_DLL_insert_tail (barrier->head,
                                    barrier->tail,
                                    client_ctx);
  barrier->nreached++;
  if ((barrier->num_wbarriers_reached == barrier->num_wbarriers) &&
      (LOCAL_QUORUM_REACHED (barrier)))
  {
    barrier->status = GNUNET_TESTBED_BARRIERSTATUS_CROSSED;
    send_barrier_status_msg (barrier,
                             NULL);
  }
  GNUNET_SERVICE_client_continue (client_ctx->client);
}

References ClientCtx::barrier, barrier_map, ClientCtx::client, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CRYPTO_hash(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_TESTBED_BARRIERSTATUS_CROSSED, Barrier::head, key, LOCAL_QUORUM_REACHED, LOG_DEBUG, msg, name, Barrier::nreached, Barrier::num_wbarriers, Barrier::num_wbarriers_reached, send_barrier_status_msg(), GNUNET_MessageHeader::size, Barrier::status, and Barrier::tail.

Here is the call graph for this function:

connect_cb()

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

static

Function called when a client connects to the testbed-barrier service.

Parameters

cls	NULL
client	the connecting client
mq	queue to talk to client

Returns

our struct ClientCtx

Definition at line 420 of file gnunet-service-testbed_barriers.c.

{
  struct ClientCtx *client_ctx;
 
  LOG_DEBUG ("Client connected to testbed-barrier service\n");
  client_ctx = GNUNET_new (struct ClientCtx);
  client_ctx->client = client;
  return client_ctx;
}

References ClientCtx::client, GNUNET_new, and LOG_DEBUG.

Referenced by GST_barriers_init().

Here is the caller graph for this function:

disconnect_cb()

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

static

Functions with this signature are called whenever a client is disconnected on the network level.

Parameters

cls	closure
client	identification of the client; NULL for the last call when the server is destroyed

Definition at line 442 of file gnunet-service-testbed_barriers.c.

{
  struct ClientCtx *client_ctx = app_ctx;
  struct Barrier *barrier = client_ctx->barrier;
 
  if (NULL != barrier)
  {
    GNUNET_CONTAINER_DLL_remove (barrier->head,
                                 barrier->tail,
                                 client_ctx);
    client_ctx->barrier = NULL;
  }
  GNUNET_free (client_ctx);
  LOG_DEBUG ("Client disconnected from testbed-barrier service\n");
}

References ClientCtx::barrier, GNUNET_CONTAINER_DLL_remove, GNUNET_free, Barrier::head, LOG_DEBUG, and Barrier::tail.

Referenced by GST_barriers_init().

Here is the caller graph for this function:

GST_barriers_init()

void GST_barriers_init

(

struct GNUNET_CONFIGURATION_Handle *

cfg

)

Function to initialise barriers component.

Parameters

cfg	the configuration to use for initialisation

Definition at line 467 of file gnunet-service-testbed_barriers.c.

{
  struct GNUNET_MQ_MessageHandler message_handlers[] = {
    GNUNET_MQ_hd_var_size (barrier_wait,
                           GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT,
                           struct GNUNET_TESTBED_BarrierWait,
                           NULL),
    GNUNET_MQ_handler_end ()
  };
 
  LOG_DEBUG ("Launching testbed-barrier service\n");
  barrier_map = GNUNET_CONTAINER_multihashmap_create (3,
                                                      GNUNET_YES);
  ctx = GNUNET_SERVICE_start ("testbed-barrier",
                              cfg,
                              &connect_cb,
                              &disconnect_cb,
                              NULL,
                              message_handlers);
}

References barrier_map, cfg, connect_cb(), ctx, disconnect_cb(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_SERVICE_start(), GNUNET_YES, and LOG_DEBUG.

Referenced by testbed_run().

Here is the call graph for this function:

Here is the caller graph for this function:

barrier_destroy_iterator()

static int barrier_destroy_iterator ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Iterator over hash 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 500 of file gnunet-service-testbed_barriers.c.

{
  struct Barrier *barrier = value;
 
  GNUNET_assert (NULL != barrier);
  cancel_wrappers (barrier);
  remove_barrier (barrier);
  return GNUNET_YES;
}

References cancel_wrappers(), GNUNET_assert, GNUNET_YES, remove_barrier(), and value.

Referenced by GST_barriers_destroy().

Here is the call graph for this function:

Here is the caller graph for this function:

GST_barriers_destroy()

void GST_barriers_destroy

(

void

)

Function to stop the barrier service.

Definition at line 517 of file gnunet-service-testbed_barriers.c.

{
  GNUNET_assert (NULL != barrier_map);
  GNUNET_assert (GNUNET_SYSERR !=
                 GNUNET_CONTAINER_multihashmap_iterate (barrier_map,
                                                        &
                                                        barrier_destroy_iterator,
                                                        NULL));
  GNUNET_CONTAINER_multihashmap_destroy (barrier_map);
  GNUNET_assert (NULL != ctx);
  GNUNET_SERVICE_stop (ctx);
}

References barrier_destroy_iterator(), barrier_map, ctx, GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_SERVICE_stop(), and GNUNET_SYSERR.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

wbarrier_status_cb()

static void wbarrier_status_cb ( void *  cls, const char *  name, struct GNUNET_TESTBED_Barrier *  b_, enum GNUNET_TESTBED_BarrierStatus  status, const char *  emsg  )

static

Functions of this type are to be given as callback argument to GNUNET_TESTBED_barrier_init().

The callback will be called when status information is available for the barrier.

Parameters

cls	the closure given to GNUNET_TESTBED_barrier_init()
name	the name of the barrier
b_	the barrier handle
status	status of the barrier; GNUNET_OK if the barrier is crossed; GNUNET_SYSERR upon error
emsg	if the status were to be GNUNET_SYSERR, this parameter has the error message

Definition at line 545 of file gnunet-service-testbed_barriers.c.

{
  struct WBarrier *wrapper = cls;
  struct Barrier *barrier = wrapper->barrier;
 
  GNUNET_assert (b_ == wrapper->hbarrier);
  switch (status)
  {
  case GNUNET_TESTBED_BARRIERSTATUS_ERROR:
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Initialising barrier `%s' failed at a sub-controller: %s\n",
         barrier->name,
         (NULL != emsg) ? emsg : "NULL");
    cancel_wrappers (barrier);
    if (NULL == emsg)
      emsg = "Initialisation failed at a sub-controller";
    barrier->status = GNUNET_TESTBED_BARRIERSTATUS_ERROR;
    send_barrier_status_msg (barrier, emsg);
    return;
 
  case GNUNET_TESTBED_BARRIERSTATUS_CROSSED:
    if (GNUNET_TESTBED_BARRIERSTATUS_INITIALISED != barrier->status)
    {
      GNUNET_break_op (0);
      return;
    }
    barrier->num_wbarriers_reached++;
    if ((barrier->num_wbarriers_reached == barrier->num_wbarriers)
        && (LOCAL_QUORUM_REACHED (barrier)))
    {
      barrier->status = GNUNET_TESTBED_BARRIERSTATUS_CROSSED;
      send_barrier_status_msg (barrier, NULL);
    }
    return;
 
  case GNUNET_TESTBED_BARRIERSTATUS_INITIALISED:
    if (0 != barrier->status)
    {
      GNUNET_break_op (0);
      return;
    }
    barrier->num_wbarriers_inited++;
    if (barrier->num_wbarriers_inited == barrier->num_wbarriers)
    {
      barrier->status = GNUNET_TESTBED_BARRIERSTATUS_INITIALISED;
      send_barrier_status_msg (barrier, NULL);
    }
    return;
  }
}

References WBarrier::barrier, cancel_wrappers(), GNUNET_assert, GNUNET_break_op, GNUNET_ERROR_TYPE_ERROR, GNUNET_TESTBED_BARRIERSTATUS_CROSSED, GNUNET_TESTBED_BARRIERSTATUS_ERROR, GNUNET_TESTBED_BARRIERSTATUS_INITIALISED, WBarrier::hbarrier, LOCAL_QUORUM_REACHED, LOG, Barrier::name, Barrier::num_wbarriers, Barrier::num_wbarriers_inited, Barrier::num_wbarriers_reached, send_barrier_status_msg(), Barrier::status, and status.

Referenced by handle_barrier_init().

Here is the call graph for this function:

Here is the caller graph for this function:

fwd_tout_barrier_init()

static void fwd_tout_barrier_init ( void *  cls )

static

Function called upon timeout while waiting for a response from the subcontrollers to barrier init message.

Parameters

cls

barrier

Definition at line 608 of file gnunet-service-testbed_barriers.c.

{
  struct Barrier *barrier = cls;
 
  cancel_wrappers (barrier);
  barrier->status = GNUNET_TESTBED_BARRIERSTATUS_ERROR;
  send_barrier_status_msg (barrier,
                           "Timedout while propagating barrier initialisation\n");
  remove_barrier (barrier);
}

References cancel_wrappers(), GNUNET_TESTBED_BARRIERSTATUS_ERROR, remove_barrier(), send_barrier_status_msg(), and Barrier::status.

Referenced by handle_barrier_init().

Here is the call graph for this function:

Here is the caller graph for this function:

check_barrier_init()

int check_barrier_init	(	void *	cls,
		const struct GNUNET_TESTBED_BarrierInit *	msg
	)

Check GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT messages.

Parameters

cls	identification of the client
msg	the actual message

Returns

GNUNET_OK if msg is well-formed

Definition at line 628 of file gnunet-service-testbed_barriers.c.

{
  return GNUNET_OK; /* always well-formed */
}

References GNUNET_OK.

handle_barrier_init()

void handle_barrier_init	(	void *	cls,
		const struct GNUNET_TESTBED_BarrierInit *	msg
	)

Message handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT messages.

This message should always come from a parent controller or the testbed API if we are the root controller.

This handler is queued in the main service and will handle the messages sent either from the testbed driver or from a high level controller

Parameters

cls	identification of the client
msg	the actual message

Definition at line 647 of file gnunet-service-testbed_barriers.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  char *name;
  struct Barrier *barrier;
  struct Slave *slave;
  struct WBarrier *wrapper;
  struct GNUNET_HashCode hash;
  size_t name_len;
  unsigned int cnt;
  uint16_t msize;
 
  if (NULL == GST_context)
  {
    GNUNET_break_op (0);
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  if (client != GST_context->client)
  {
    GNUNET_break_op (0);
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  msize = ntohs (msg->header.size);
  name_len = (size_t) msize - sizeof(struct GNUNET_TESTBED_BarrierInit);
  name = GNUNET_malloc (name_len + 1);
  GNUNET_memcpy (name, msg->name, name_len);
  GNUNET_CRYPTO_hash (name, name_len, &hash);
  LOG_DEBUG ("Received BARRIER_INIT for barrier `%s'\n",
             name);
  if (GNUNET_YES ==
      GNUNET_CONTAINER_multihashmap_contains (barrier_map,
                                              &hash))
  {
    send_client_status_msg (client,
                            name,
                            GNUNET_TESTBED_BARRIERSTATUS_ERROR,
                            "A barrier with the same name already exists");
    GNUNET_free (name);
    GNUNET_SERVICE_client_continue (client);
    return;
  }
  barrier = GNUNET_new (struct Barrier);
  barrier->hash = hash;
  barrier->quorum = msg->quorum;
  barrier->name = name;
  barrier->mc = client;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multihashmap_put (barrier_map,
                                                    &barrier->hash,
                                                    barrier,
                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
  GNUNET_SERVICE_client_continue (client);
  /* Propagate barrier init to subcontrollers */
  for (cnt = 0; cnt < GST_slave_list_size; cnt++)
  {
    if (NULL == (slave = GST_slave_list[cnt]))
      continue;
    if (NULL == slave->controller)
    {
      GNUNET_break (0);   /* May happen when we are connecting to the controller */
      continue;
    }
    wrapper = GNUNET_new (struct WBarrier);
    wrapper->barrier = barrier;
    wrapper->controller = slave->controller;
    GNUNET_CONTAINER_DLL_insert_tail (barrier->whead,
                                      barrier->wtail,
                                      wrapper);
    barrier->num_wbarriers++;
    wrapper->hbarrier = GNUNET_TESTBED_barrier_init_ (wrapper->controller,
                                                      barrier->name,
                                                      barrier->quorum,
                                                      &wbarrier_status_cb,
                                                      wrapper,
                                                      GNUNET_NO);
  }
  if (NULL == barrier->whead)   /* No further propagation */
  {
    barrier->status = GNUNET_TESTBED_BARRIERSTATUS_INITIALISED;
    LOG_DEBUG (
      "Sending GNUNET_TESTBED_BARRIERSTATUS_INITIALISED for barrier `%s'\n",
      barrier->name);
    send_barrier_status_msg (barrier, NULL);
  }
  else
    barrier->tout_task = GNUNET_SCHEDULER_add_delayed (MESSAGE_SEND_TIMEOUT (
                                                         30),
                                                       &fwd_tout_barrier_init,
                                                       barrier);
}

References WBarrier::barrier, barrier_map, Context::client, WBarrier::controller, Slave::controller, fwd_tout_barrier_init(), GNUNET_assert, GNUNET_break, GNUNET_break_op, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_CRYPTO_hash(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_TESTBED_barrier_init_(), GNUNET_TESTBED_BARRIERSTATUS_ERROR, GNUNET_TESTBED_BARRIERSTATUS_INITIALISED, GNUNET_YES, GST_context, GST_slave_list, GST_slave_list_size, Barrier::hash, WBarrier::hbarrier, LOG_DEBUG, Barrier::mc, MESSAGE_SEND_TIMEOUT, msg, name, Barrier::name, Barrier::num_wbarriers, Barrier::quorum, send_barrier_status_msg(), send_client_status_msg(), GNUNET_MessageHeader::size, Barrier::status, Barrier::tout_task, wbarrier_status_cb(), Barrier::whead, and Barrier::wtail.

Here is the call graph for this function:

check_barrier_cancel()

int check_barrier_cancel	(	void *	cls,
		const struct GNUNET_TESTBED_BarrierCancel *	msg
	)

Check GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL messages.

Parameters

cls	identification of the client
msg	the actual message

Returns

GNUNET_OK if msg is well-formed

Definition at line 750 of file gnunet-service-testbed_barriers.c.

{
  return GNUNET_OK; /* all are well-formed */
}

References GNUNET_OK.

handle_barrier_cancel()

void handle_barrier_cancel	(	void *	cls,
		const struct GNUNET_TESTBED_BarrierCancel *	msg
	)

Message handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL messages.

This message should always come from a parent controller or the testbed API if we are the root controller.

This handler is queued in the main service and will handle the messages sent either from the testbed driver or from a high level controller

Parameters

cls	identification of the client
msg	the actual message

Definition at line 769 of file gnunet-service-testbed_barriers.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  char *name;
  struct Barrier *barrier;
  struct GNUNET_HashCode hash;
  size_t name_len;
  uint16_t msize;
 
  if (NULL == GST_context)
  {
    GNUNET_break_op (0);
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  if (client != GST_context->client)
  {
    GNUNET_break_op (0);
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  msize = ntohs (msg->header.size);
  name_len = msize - sizeof(struct GNUNET_TESTBED_BarrierCancel);
  name = GNUNET_malloc (name_len + 1);
  GNUNET_memcpy (name,
                 msg->name,
                 name_len);
  LOG_DEBUG ("Received BARRIER_CANCEL for barrier `%s'\n",
             name);
  GNUNET_CRYPTO_hash (name,
                      name_len,
                      &hash);
  if (GNUNET_NO ==
      GNUNET_CONTAINER_multihashmap_contains (barrier_map,
                                              &hash))
  {
    GNUNET_break_op (0);
    GNUNET_free (name);
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  barrier = GNUNET_CONTAINER_multihashmap_get (barrier_map,
                                               &hash);
  GNUNET_assert (NULL != barrier);
  cancel_wrappers (barrier);
  remove_barrier (barrier);
  GNUNET_free (name);
  GNUNET_SERVICE_client_continue (client);
}

References barrier_map, cancel_wrappers(), Context::client, GNUNET_assert, GNUNET_break_op, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CRYPTO_hash(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GST_context, LOG_DEBUG, msg, name, remove_barrier(), and GNUNET_MessageHeader::size.

Here is the call graph for this function:

check_barrier_status()

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

Check GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS messages.

Parameters

cls	identification of the client
msg	the actual message

Returns

GNUNET_OK if msg is well-formed

Definition at line 829 of file gnunet-service-testbed_barriers.c.

{
  uint16_t msize;
  uint16_t name_len;
  const char *name;
  enum GNUNET_TESTBED_BarrierStatus status;
 
  msize = ntohs (msg->header.size) - sizeof(*msg);
  status = ntohs (msg->status);
  if (GNUNET_TESTBED_BARRIERSTATUS_CROSSED != status)
  {
    GNUNET_break_op (0);        /* current we only expect BARRIER_CROSSED
                                   status message this way */
    return GNUNET_SYSERR;
  }
  name = msg->data;
  name_len = ntohs (msg->name_len);
  if ((name_len + 1) != msize)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if ('\0' != name[name_len])
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, GNUNET_TESTBED_BARRIERSTATUS_CROSSED, msg, name, GNUNET_MessageHeader::size, and status.

handle_barrier_status()

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

Message handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS messages.

This handler is queued in the main service and will handle the messages sent either from the testbed driver or from a high level controller

Parameters

cls	identification of the client
msg	the actual message

The wrapper barriers do not echo the barrier status, so we have to do it here

Definition at line 870 of file gnunet-service-testbed_barriers.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct Barrier *barrier;
  struct ClientCtx *client_ctx;
  struct WBarrier *wrapper;
  const char *name;
  struct GNUNET_HashCode key;
  uint16_t name_len;
  struct GNUNET_MQ_Envelope *env;
 
  if (NULL == GST_context)
  {
    GNUNET_break_op (0);
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  if (client != GST_context->client)
  {
    GNUNET_break_op (0);
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  name = msg->data;
  name_len = ntohs (msg->name_len);
  LOG_DEBUG ("Received BARRIER_STATUS for barrier `%s'\n",
             name);
  GNUNET_CRYPTO_hash (name,
                      name_len,
                      &key);
  barrier = GNUNET_CONTAINER_multihashmap_get (barrier_map,
                                               &key);
  if (NULL == barrier)
  {
    GNUNET_break_op (0);
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  GNUNET_SERVICE_client_continue (client);
  for (client_ctx = barrier->head; NULL != client_ctx; client_ctx =
         client_ctx->next)                                                            /* Notify peers */
  {
    env = GNUNET_MQ_msg_copy (&msg->header);
    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client_ctx->client),
                    env);
  }
  for (wrapper = barrier->whead; NULL != wrapper; wrapper = wrapper->next)
  {
    GNUNET_TESTBED_queue_message_ (wrapper->controller,
                                   GNUNET_copy_message (&msg->header));
  }
}

References barrier_map, Context::client, ClientCtx::client, WBarrier::controller, env, GNUNET_break_op, GNUNET_CONTAINER_multihashmap_get(), GNUNET_copy_message(), GNUNET_CRYPTO_hash(), GNUNET_MQ_msg_copy(), GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SERVICE_client_get_mq(), GNUNET_TESTBED_queue_message_(), GST_context, Barrier::head, key, LOG_DEBUG, msg, name, ClientCtx::next, WBarrier::next, and Barrier::whead.

Here is the call graph for this function:

Variable Documentation

barrier_map

struct GNUNET_CONTAINER_MultiHashMap* barrier_map

static

Hashtable handle for storing initialised barriers.

Definition at line 213 of file gnunet-service-testbed_barriers.c.

Referenced by GST_barriers_destroy(), GST_barriers_init(), handle_barrier_cancel(), handle_barrier_init(), handle_barrier_status(), handle_barrier_wait(), and remove_barrier().

ctx

struct GNUNET_SERVICE_Handle* ctx

static

Service context.

Definition at line 218 of file gnunet-service-testbed_barriers.c.

Referenced by GST_barriers_destroy(), GST_barriers_init(), and remove_barrier().