gnunet-service-testbed_barriers.h File Reference

Interface for the barrier initialisation handler routine. More...

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

Go to the source code of this file.

Functions
void	GST_barriers_init (struct GNUNET_CONFIGURATION_Handle *cfg)
	Function to initialise barrriers component. More...
void	GST_barriers_destroy (void)
	Function to stop the barrier service. 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...

Detailed Description

Interface for the barrier initialisation handler routine.

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.h.

Function Documentation

GST_barriers_init()

void GST_barriers_init

(

struct GNUNET_CONFIGURATION_Handle *

cfg

)

Function to initialise barrriers component.

Parameters

cfg	the configuration to use for initialisation

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

References connect_cb(), 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().

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

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 513 of file gnunet-service-testbed_barriers.c.

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

Referenced by shutdown_task().

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

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 624 of file gnunet-service-testbed_barriers.c.

References GNUNET_OK.

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

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 643 of file gnunet-service-testbed_barriers.c.

References ClientCtx::barrier, WBarrier::barrier, ClientCtx::client, Context::client, Slave::controller, WBarrier::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, GNUNET_TESTBED_BarrierInit::header, LOG_DEBUG, Barrier::mc, MESSAGE_SEND_TIMEOUT, Barrier::name, name, GNUNET_TESTBED_BarrierInit::name, Barrier::num_wbarriers, Barrier::quorum, GNUNET_TESTBED_BarrierInit::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.

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

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 744 of file gnunet-service-testbed_barriers.c.

References GNUNET_OK.

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

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 763 of file gnunet-service-testbed_barriers.c.

References ClientCtx::barrier, cancel_wrappers(), ClientCtx::client, Context::client, GNUNET_assert, GNUNET_break_op, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CRYPTO_hash(), GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GST_context, GNUNET_TESTBED_BarrierCancel::header, LOG_DEBUG, name, GNUNET_TESTBED_BarrierCancel::name, remove_barrier(), and GNUNET_MessageHeader::size.

{
  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_SERVICE_client_drop(client);
      return;
    }
  barrier = GNUNET_CONTAINER_multihashmap_get(barrier_map,
                                              &hash);
  GNUNET_assert(NULL != barrier);
  cancel_wrappers(barrier);
  remove_barrier(barrier);
  GNUNET_SERVICE_client_continue(client);
}

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 821 of file gnunet-service-testbed_barriers.c.

References GNUNET_TESTBED_BarrierStatusMsg::data, GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, GNUNET_TESTBED_BARRIERSTATUS_CROSSED, GNUNET_TESTBED_BarrierStatusMsg::header, name, GNUNET_TESTBED_BarrierStatusMsg::name_len, GNUNET_MessageHeader::size, status, and GNUNET_TESTBED_BarrierStatusMsg::status.

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

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 862 of file gnunet-service-testbed_barriers.c.

References ClientCtx::barrier, ClientCtx::client, Context::client, WBarrier::controller, GNUNET_TESTBED_BarrierStatusMsg::data, 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, GNUNET_TESTBED_BarrierStatusMsg::header, LOG_DEBUG, name, GNUNET_TESTBED_BarrierStatusMsg::name_len, ClientCtx::next, WBarrier::next, and Barrier::whead.

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

Here is the call graph for this function: