GNUnet  0.17.6
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.


void GST_barriers_init (struct GNUNET_CONFIGURATION_Handle *cfg)
 Function to initialise barriers 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)
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)
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)
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.

Sree Harsha Totakura

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 barriers component.

cfgthe configuration to use for initialisation

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

467 {
468  struct GNUNET_MQ_MessageHandler message_handlers[] = {
469  GNUNET_MQ_hd_var_size (barrier_wait,
472  NULL),
474  };
476  LOG_DEBUG ("Launching testbed-barrier service\n");
479  ctx = GNUNET_SERVICE_start ("testbed-barrier",
480  cfg,
481  &connect_cb,
482  &disconnect_cb,
483  NULL,
484  message_handlers);
485 }
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
#define LOG_DEBUG(...)
Debug logging shorthand.
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.
static struct GNUNET_SERVICE_Handle * ctx
Service context.
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.
static struct GNUNET_CONTAINER_MultiHashMap * barrier_map
Hashtable handle for storing initialised barriers.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
Message sent by a peer when it has reached a barrier and is waiting for it to be crossed.
struct GNUNET_SERVICE_Handle * GNUNET_SERVICE_start(const char *service_name, const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_SERVICE_ConnectHandler connect_cb, GNUNET_SERVICE_DisconnectHandler disconnect_cb, void *cls, const struct GNUNET_MQ_MessageHandler *handlers)
Low-level function to start a service if the scheduler is already running.
Definition: service.c:1879
Message handler for a specific message type.
Message sent from peers to the testbed-barrier service to indicate that they have reached a barrier a...
Definition: testbed.h:851

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:

◆ GST_barriers_destroy()

void GST_barriers_destroy ( void  )

Function to stop the barrier service.

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

517 {
518  GNUNET_assert (NULL != barrier_map);
521  &
523  NULL));
525  GNUNET_assert (NULL != ctx);
527 }
static int barrier_destroy_iterator(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator over hash map entries.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
Definition: gnunet_common.h:97
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GNUNET_SERVICE_stop(struct GNUNET_SERVICE_Handle *srv)
Stops a service that was started with GNUNET_SERVICE_start().
Definition: service.c:1912

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:

◆ check_barrier_init()

int check_barrier_init ( void *  cls,
const struct GNUNET_TESTBED_BarrierInit msg 


clsidentification of the client
msgthe actual message
GNUNET_OK if msg is well-formed

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

629 {
630  return GNUNET_OK; /* always well-formed */
631 }
Definition: gnunet_common.h:99

References GNUNET_OK.

◆ handle_barrier_init()

void handle_barrier_init ( void *  cls,
const struct GNUNET_TESTBED_BarrierInit msg 


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

clsidentification of the client
msgthe actual message

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

648 {
649  struct GNUNET_SERVICE_Client *client = cls;
650  char *name;
651  struct Barrier *barrier;
652  struct Slave *slave;
653  struct WBarrier *wrapper;
654  struct GNUNET_HashCode hash;
655  size_t name_len;
656  unsigned int cnt;
657  uint16_t msize;
659  if (NULL == GST_context)
660  {
661  GNUNET_break_op (0);
663  return;
664  }
665  if (client != GST_context->client)
666  {
667  GNUNET_break_op (0);
669  return;
670  }
671  msize = ntohs (msg->header.size);
672  name_len = (size_t) msize - sizeof(struct GNUNET_TESTBED_BarrierInit);
673  name = GNUNET_malloc (name_len + 1);
674  GNUNET_memcpy (name, msg->name, name_len);
675  GNUNET_CRYPTO_hash (name, name_len, &hash);
676  LOG_DEBUG ("Received BARRIER_INIT for barrier `%s'\n",
677  name);
678  if (GNUNET_YES ==
680  &hash))
681  {
682  send_client_status_msg (client,
683  name,
685  "A barrier with the same name already exists");
686  GNUNET_free (name);
688  return;
689  }
690  barrier = GNUNET_new (struct Barrier);
691  barrier->hash = hash;
692  barrier->quorum = msg->quorum;
693  barrier->name = name;
694  barrier->mc = client;
697  &barrier->hash,
698  barrier,
701  /* Propagate barrier init to subcontrollers */
702  for (cnt = 0; cnt < GST_slave_list_size; cnt++)
703  {
704  if (NULL == (slave = GST_slave_list[cnt]))
705  continue;
706  if (NULL == slave->controller)
707  {
708  GNUNET_break (0); /* May happen when we are connecting to the controller */
709  continue;
710  }
711  wrapper = GNUNET_new (struct WBarrier);
712  wrapper->barrier = barrier;
713  wrapper->controller = slave->controller;
715  barrier->wtail,
716  wrapper);
717  barrier->num_wbarriers++;
718  wrapper->hbarrier = GNUNET_TESTBED_barrier_init_ (wrapper->controller,
719  barrier->name,
720  barrier->quorum,
722  wrapper,
723  GNUNET_NO);
724  }
725  if (NULL == barrier->whead) /* No further propagation */
726  {
728  LOG_DEBUG (
730  barrier->name);
731  send_barrier_status_msg (barrier, NULL);
732  }
733  else
735  30),
737  barrier);
738 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct Context * GST_context
The master context; generated with the first INIT message.
timeout for outgoing message transmissions in seconds
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().
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.
static void fwd_tout_barrier_init(void *cls)
Function called upon timeout while waiting for a response from the subcontrollers to barrier init mes...
static void send_barrier_status_msg(struct Barrier *barrier, const char *emsg)
Sends a barrier failed message.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_contains(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Check if the map contains any value under the given key (including values that are NULL).
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Definition: gnunet_common.h:98
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1254
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2329
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2248
Error status.
Barrier initialised successfully.
const char * name
uint8_t quorum
Quorum percentage to be reached.
struct GNUNET_SCHEDULER_Task * tout_task
Identifier for the timeout task.
struct WBarrier * wtail
DLL tail for the list of barrier handles.
struct GNUNET_HashCode hash
The hashcode of the barrier name.
unsigned int num_wbarriers
Number of barriers wrapped in the above DLL.
struct WBarrier * whead
DLL head for the list of barrier handles.
char * name
The name of the barrier.
enum GNUNET_TESTBED_BarrierStatus status
The status of this barrier.
struct GNUNET_SERVICE_Client * mc
The client handle to the master controller.
struct GNUNET_SERVICE_Client * client
The client handle associated with this context.
A 512-bit hashcode.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Handle to a client that is connected to a service.
Definition: service.c:251
Message to initialise a barrier.
Definition: testbed.h:783
Structure representing a connected(directly-linked) controller.
struct GNUNET_TESTBED_Controller * controller
The controller handle.
Wrapper around Barrier handle.
struct Barrier * barrier
The local barrier associated with the creation of this wrapper.
struct GNUNET_TESTBED_Barrier * hbarrier
The barrier handle from API.
struct GNUNET_TESTBED_Controller * controller
Handle to the slave controller where this wrapper creates a barrier.
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...
Definition: testbed_api.c:2371

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 


clsidentification of the client
msgthe actual message
GNUNET_OK if msg is well-formed

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

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

References GNUNET_OK.

◆ handle_barrier_cancel()

void handle_barrier_cancel ( void *  cls,
const struct GNUNET_TESTBED_BarrierCancel msg 


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

clsidentification of the client
msgthe actual message

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

770 {
771  struct GNUNET_SERVICE_Client *client = cls;
772  char *name;
773  struct Barrier *barrier;
774  struct GNUNET_HashCode hash;
775  size_t name_len;
776  uint16_t msize;
778  if (NULL == GST_context)
779  {
780  GNUNET_break_op (0);
782  return;
783  }
784  if (client != GST_context->client)
785  {
786  GNUNET_break_op (0);
788  return;
789  }
790  msize = ntohs (msg->header.size);
791  name_len = msize - sizeof(struct GNUNET_TESTBED_BarrierCancel);
792  name = GNUNET_malloc (name_len + 1);
794  msg->name,
795  name_len);
796  LOG_DEBUG ("Received BARRIER_CANCEL for barrier `%s'\n",
797  name);
799  name_len,
800  &hash);
801  if (GNUNET_NO ==
803  &hash))
804  {
805  GNUNET_break_op (0);
807  return;
808  }
810  &hash);
811  GNUNET_assert (NULL != barrier);
812  cancel_wrappers (barrier);
813  remove_barrier (barrier);
815 }
static void cancel_wrappers(struct Barrier *barrier)
Cancels all subcontroller barrier handles.
static void remove_barrier(struct Barrier *barrier)
Function to remove a barrier from the barrier map and cleanup resources occupied by a barrier.
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
Message to cancel a barrier.
Definition: testbed.h:805

References barrier_map, cancel_wrappers(), 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, 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 


clsidentification of the client
msgthe actual message
GNUNET_OK if msg is well-formed

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

828 {
829  uint16_t msize;
830  uint16_t name_len;
831  const char *name;
834  msize = ntohs (msg->header.size) - sizeof(*msg);
835  status = ntohs (msg->status);
837  {
838  GNUNET_break_op (0); /* current we only expect BARRIER_CROSSED
839  status message this way */
840  return GNUNET_SYSERR;
841  }
842  name = msg->data;
843  name_len = ntohs (msg->name_len);
844  if ((name_len + 1) != msize)
845  {
846  GNUNET_break_op (0);
847  return GNUNET_SYSERR;
848  }
849  if ('\0' != name[name_len])
850  {
851  GNUNET_break_op (0);
852  return GNUNET_SYSERR;
853  }
854  return GNUNET_OK;
855 }
uint16_t status
See PRISM_STATUS_*-constants.
Status of a barrier.
Barrier is crossed.

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 


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

clsidentification of the client
msgthe actual message

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

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

869 {
870  struct GNUNET_SERVICE_Client *client = cls;
871  struct Barrier *barrier;
872  struct ClientCtx *client_ctx;
873  struct WBarrier *wrapper;
874  const char *name;
875  struct GNUNET_HashCode key;
876  uint16_t name_len;
877  struct GNUNET_MQ_Envelope *env;
879  if (NULL == GST_context)
880  {
881  GNUNET_break_op (0);
883  return;
884  }
885  if (client != GST_context->client)
886  {
887  GNUNET_break_op (0);
889  return;
890  }
891  name = msg->data;
892  name_len = ntohs (msg->name_len);
893  LOG_DEBUG ("Received BARRIER_STATUS for barrier `%s'\n",
894  name);
896  name_len,
897  &key);
899  &key);
900  if (NULL == barrier)
901  {
902  GNUNET_break_op (0);
904  return;
905  }
907  for (client_ctx = barrier->head; NULL != client_ctx; client_ctx =
908  client_ctx->next) /* Notify peers */
909  {
910  env = GNUNET_MQ_msg_copy (&msg->header);
912  env);
913  }
918  for (wrapper = barrier->whead; NULL != wrapper; wrapper = wrapper->next)
919  {
921  GNUNET_copy_message (&msg->header));
922  }
923 }
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_HashCode key
The key used in the DHT.
struct GNUNET_MessageHeader * GNUNET_copy_message(const struct GNUNET_MessageHeader *msg)
Create a copy of the given message.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:302
struct GNUNET_MQ_Envelope * GNUNET_MQ_msg_copy(const struct GNUNET_MessageHeader *hdr)
Create a new envelope by copying an existing message.
Definition: mq.c:535
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2442
struct ClientCtx * head
DLL head for the list of clients waiting for this barrier.
Context to be associated with each client.
struct ClientCtx * next
DLL next ptr.
struct GNUNET_SERVICE_Client * client
The client handle.
struct WBarrier * next
DLL next pointer.
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.
Definition: testbed_api.c:1336

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: