GNUnet  0.11.x
Data Structures | Macros | Functions | Variables
gnunet-service-testbed_barriers.c File Reference

barrier handling at the testbed controller More...

#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 barrriers 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_MultiHashMapbarrier_map
 Hashtable handle for storing initialised barriers. More...
 
static struct GNUNET_SERVICE_Handlectx
 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 35 of file gnunet-service-testbed_barriers.c.

Referenced by handle_barrier_init().

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

Referenced by handle_barrier_wait(), and wbarrier_status_cb().

◆ LOG

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

Logging shorthand.

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

Referenced by wbarrier_status_cb().

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
barrierthe barrier handle

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

References ClientCtx::barrier, 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().

228 {
229  struct ClientCtx *ctx;
230 
233  &barrier->hash,
234  barrier));
235  while (NULL != (ctx = barrier->head))
236  {
238  barrier->tail,
239  ctx);
240  ctx->barrier = NULL;
241  }
242  GNUNET_free (barrier->name);
243  GNUNET_free (barrier);
244 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Context to be associated with each client.
static struct GNUNET_CONTAINER_MultiHashMap * barrier_map
Hashtable handle for storing initialised barriers.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_SERVICE_Handle * ctx
Service context.
int GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
struct GNUNET_HashCode hash
The hashcode of the barrier name.
char * name
The name of the barrier.
struct ClientCtx * head
DLL head for the list of clients waiting for this barrier.
struct ClientCtx * tail
DLL tail for the list of clients waiting for this barrier.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct Barrier * barrier
The barrier this client is waiting for.
#define GNUNET_free(ptr)
Wrapper around free.
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
barrierthe local barrier

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

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

254 {
255  struct WBarrier *wrapper;
256 
257  while (NULL != (wrapper = barrier->whead))
258  {
261  barrier->wtail,
262  wrapper);
263  GNUNET_free (wrapper);
264  }
265 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct WBarrier * wtail
DLL tail for the list of barrier handles.
struct GNUNET_TESTBED_Barrier * hbarrier
The barrier handle from API.
struct WBarrier * whead
DLL head for the list of barrier handles.
void GNUNET_TESTBED_barrier_cancel(struct GNUNET_TESTBED_Barrier *barrier)
Cancel a barrier.
Definition: testbed_api.c:2458
Wrapper around Barrier handle.
#define GNUNET_free(ptr)
Wrapper around free.
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
clientthe client to send the message to
namethe barrier name
statusthe status of the barrier
emsgthe error message; should be non-NULL for status=GNUNET_TESTBED_BARRIERSTATUS_ERROR

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

References GNUNET_TESTBED_BarrierStatusMsg::data, 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, GNUNET_TESTBED_BarrierStatusMsg::name_len, and GNUNET_TESTBED_BarrierStatusMsg::status.

Referenced by handle_barrier_init(), and send_barrier_status_msg().

282 {
283  struct GNUNET_MQ_Envelope *env;
285  size_t name_len;
286  size_t err_len;
287 
288  GNUNET_assert ((NULL == emsg) ||
290  name_len = strlen (name) + 1;
291  err_len = ((NULL == emsg) ? 0 : (strlen (emsg) + 1));
292  env = GNUNET_MQ_msg_extra (msg,
293  name_len + err_len,
295  msg->status = htons (status);
296  msg->name_len = htons ((uint16_t) name_len - 1);
297  GNUNET_memcpy (msg->data,
298  name,
299  name_len);
300  GNUNET_memcpy (msg->data + name_len,
301  emsg,
302  err_len);
304  env);
305 }
#define GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS
Message for signalling status of a barrier.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
uint16_t name_len
strlen of the barrier name
Definition: testbed.h:836
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2437
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
uint16_t status
status.
Definition: testbed.h:831
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
uint16_t status
See PRISM_STATUS_*-constants.
char data[0]
the barrier name (0-terminated) concatenated with an error message (0-terminated) if the status were ...
Definition: testbed.h:842
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
const char * name
Message for signalling status changes of a barrier.
Definition: testbed.h:821
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:353
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
barrierthe corresponding barrier
emsgthe error message; should be non-NULL for status=GNUNET_TESTBED_BARRIERSTATUS_ERROR

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

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().

318 {
319  GNUNET_assert (0 != barrier->status);
320  send_client_status_msg (barrier->mc,
321  barrier->name,
322  barrier->status,
323  emsg);
324 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
enum GNUNET_TESTBED_BarrierStatus status
The status of this barrier.
struct GNUNET_SERVICE_Client * mc
The client handle to the master controller.
char * name
The name of the barrier.
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.
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
clsidentification of the client
messagethe actual message

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

References GNUNET_OK.

336 {
337  return GNUNET_OK; /* always well-formed */
338 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75

◆ 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
clsidentification of the client
messagethe actual message

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

References ClientCtx::barrier, 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, GNUNET_TESTBED_BarrierWait::header, LOCAL_QUORUM_REACHED, LOG_DEBUG, name, GNUNET_TESTBED_BarrierWait::name, Barrier::nreached, Barrier::num_wbarriers, Barrier::num_wbarriers_reached, send_barrier_status_msg(), GNUNET_MessageHeader::size, Barrier::status, and Barrier::tail.

355 {
356  struct ClientCtx *client_ctx = cls;
357  struct Barrier *barrier;
358  char *name;
359  struct GNUNET_HashCode key;
360  size_t name_len;
361  uint16_t msize;
362 
363  msize = ntohs (msg->header.size);
364  if (NULL == barrier_map)
365  {
366  GNUNET_break (0);
367  GNUNET_SERVICE_client_drop (client_ctx->client);
368  return;
369  }
370  name_len = msize - sizeof(struct GNUNET_TESTBED_BarrierWait);
371  name = GNUNET_malloc (name_len + 1);
372  name[name_len] = '\0';
373  GNUNET_memcpy (name,
374  msg->name,
375  name_len);
376  LOG_DEBUG ("Received BARRIER_WAIT for barrier `%s'\n",
377  name);
378  GNUNET_CRYPTO_hash (name,
379  name_len,
380  &key);
381  GNUNET_free (name);
382  if (NULL == (barrier = GNUNET_CONTAINER_multihashmap_get (barrier_map, &key)))
383  {
384  GNUNET_break (0);
385  GNUNET_SERVICE_client_drop (client_ctx->client);
386  return;
387  }
388  if (NULL != client_ctx->barrier)
389  {
390  GNUNET_break (0);
391  GNUNET_SERVICE_client_drop (client_ctx->client);
392  return;
393  }
394  client_ctx->barrier = barrier;
396  barrier->tail,
397  client_ctx);
398  barrier->nreached++;
399  if ((barrier->num_wbarriers_reached == barrier->num_wbarriers) &&
400  (LOCAL_QUORUM_REACHED (barrier)))
401  {
403  send_barrier_status_msg (barrier,
404  NULL);
405  }
407 }
unsigned int num_wbarriers_reached
Number of wrapped barriers reached so far.
Context to be associated with each client.
char name[0]
The name of the barrier they have reached.
Definition: testbed.h:860
static struct GNUNET_CONTAINER_MultiHashMap * barrier_map
Hashtable handle for storing initialised barriers.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
static void send_barrier_status_msg(struct Barrier *barrier, const char *emsg)
Sends a barrier failed message.
enum GNUNET_TESTBED_BarrierStatus status
The status of this barrier.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Message sent from peers to the testbed-barrier service to indicate that they have reached a barrier a...
Definition: testbed.h:850
unsigned int num_wbarriers
Number of barriers wrapped in the above DLL.
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.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:48
unsigned int nreached
Number of peers which have reached this barrier.
A 512-bit hashcode.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2324
struct GNUNET_HashCode key
The key used in the DHT.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
#define LOCAL_QUORUM_REACHED(barrier)
Test to see if local peers have reached the required quorum of a barrier.
struct GNUNET_SERVICE_Client * client
The client handle.
const char * name
struct ClientCtx * head
DLL head for the list of clients waiting for this barrier.
struct ClientCtx * tail
DLL tail for the list of clients waiting for this barrier.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT.
Definition: testbed.h:855
struct Barrier * barrier
The barrier this client is waiting for.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
#define LOG_DEBUG(...)
Debug logging shorthand.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
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
clsNULL
clientthe connecting client
mqqueue to talk to client
Returns
our struct ClientCtx

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

References ClientCtx::client, GNUNET_new, and LOG_DEBUG.

Referenced by GST_barriers_init().

422 {
423  struct ClientCtx *client_ctx;
424 
425  LOG_DEBUG ("Client connected to testbed-barrier service\n");
426  client_ctx = GNUNET_new (struct ClientCtx);
427  client_ctx->client = client;
428  return client_ctx;
429 }
Context to be associated with each client.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_SERVICE_Client * client
The client handle.
#define LOG_DEBUG(...)
Debug logging shorthand.
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
clsclosure
clientidentification of the client; NULL for the last call when the server is destroyed

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

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

Referenced by GST_barriers_init().

444 {
445  struct ClientCtx *client_ctx = app_ctx;
446  struct Barrier *barrier = client_ctx->barrier;
447 
448  if (NULL != barrier)
449  {
451  barrier->tail,
452  client_ctx);
453  client_ctx->barrier = NULL;
454  }
455  GNUNET_free (client_ctx);
456  LOG_DEBUG ("Client disconnected from testbed-barrier service\n");
457 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Context to be associated with each client.
struct ClientCtx * head
DLL head for the list of clients waiting for this barrier.
struct ClientCtx * tail
DLL tail for the list of clients waiting for this barrier.
struct Barrier * barrier
The barrier this client is waiting for.
#define LOG_DEBUG(...)
Debug logging shorthand.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the caller graph for this function:

◆ GST_barriers_init()

void GST_barriers_init ( struct GNUNET_CONFIGURATION_Handle cfg)

Function to initialise barrriers component.

Parameters
cfgthe configuration to use for initialisation

Definition at line 466 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().

467 {
468  struct GNUNET_MQ_MessageHandler message_handlers[] = {
469  GNUNET_MQ_hd_var_size (barrier_wait,
472  NULL),
474  };
475 
476  LOG_DEBUG ("Launching testbed-barrier service\n");
478  GNUNET_YES);
479  ctx = GNUNET_SERVICE_start ("testbed-barrier",
480  cfg,
481  &connect_cb,
482  &disconnect_cb,
483  NULL,
484  message_handlers);
485 }
static struct GNUNET_CONTAINER_MultiHashMap * barrier_map
Hashtable handle for storing initialised barriers.
#define GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT
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:1878
Message sent from peers to the testbed-barrier service to indicate that they have reached a barrier a...
Definition: testbed.h:850
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
static struct GNUNET_SERVICE_Handle * ctx
Service context.
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...
Message handler for a specific message type.
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.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
#define GNUNET_YES
Definition: gnunet_common.h:77
#define LOG_DEBUG(...)
Debug logging shorthand.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
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
clsclosure
keycurrent key code
valuevalue in the hash map
Returns
GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

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

References ClientCtx::barrier, cancel_wrappers(), GNUNET_assert, GNUNET_YES, remove_barrier(), and value.

Referenced by GST_barriers_destroy().

502 {
503  struct Barrier *barrier = value;
504 
505  GNUNET_assert (NULL != barrier);
506  cancel_wrappers (barrier);
507  remove_barrier (barrier);
508  return GNUNET_YES;
509 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static char * value
Value of the record to add/remove.
static void cancel_wrappers(struct Barrier *barrier)
Cancels all subcontroller barrier handles.
#define GNUNET_YES
Definition: gnunet_common.h:77
static void remove_barrier(struct Barrier *barrier)
Function to remove a barrier from the barrier map and cleanup resources occupied by a barrier...
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.

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

Referenced by shutdown_task().

517 {
518  GNUNET_assert (NULL != barrier_map);
521  &
523  NULL));
525  GNUNET_assert (NULL != ctx);
527 }
static struct GNUNET_CONTAINER_MultiHashMap * barrier_map
Hashtable handle for storing initialised barriers.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
static struct GNUNET_SERVICE_Handle * ctx
Service context.
void GNUNET_SERVICE_stop(struct GNUNET_SERVICE_Handle *srv)
Stops a service that was started with GNUNET_SERVICE_start().
Definition: service.c:1911
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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.
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
clsthe closure given to GNUNET_TESTBED_barrier_init()
namethe name of the barrier
b_the barrier handle
statusstatus of the barrier; GNUNET_OK if the barrier is crossed; GNUNET_SYSERR upon error
emsgif the status were to be GNUNET_SYSERR, this parameter has the error messsage

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

References ClientCtx::barrier, 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(), and Barrier::status.

Referenced by handle_barrier_init().

549 {
550  struct WBarrier *wrapper = cls;
551  struct Barrier *barrier = wrapper->barrier;
552 
553  GNUNET_assert (b_ == wrapper->hbarrier);
554  switch (status)
555  {
558  "Initialising barrier `%s' failed at a sub-controller: %s\n",
559  barrier->name,
560  (NULL != emsg) ? emsg : "NULL");
561  cancel_wrappers (barrier);
562  if (NULL == emsg)
563  emsg = "Initialisation failed at a sub-controller";
565  send_barrier_status_msg (barrier, emsg);
566  return;
567 
570  {
571  GNUNET_break_op (0);
572  return;
573  }
574  barrier->num_wbarriers_reached++;
575  if ((barrier->num_wbarriers_reached == barrier->num_wbarriers)
576  && (LOCAL_QUORUM_REACHED (barrier)))
577  {
579  send_barrier_status_msg (barrier, NULL);
580  }
581  return;
582 
584  if (0 != barrier->status)
585  {
586  GNUNET_break_op (0);
587  return;
588  }
589  barrier->num_wbarriers_inited++;
590  if (barrier->num_wbarriers_inited == barrier->num_wbarriers)
591  {
593  send_barrier_status_msg (barrier, NULL);
594  }
595  return;
596  }
597 }
unsigned int num_wbarriers_reached
Number of wrapped barriers reached so far.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void send_barrier_status_msg(struct Barrier *barrier, const char *emsg)
Sends a barrier failed message.
struct GNUNET_TESTBED_Barrier * hbarrier
The barrier handle from API.
enum GNUNET_TESTBED_BarrierStatus status
The status of this barrier.
unsigned int num_wbarriers
Number of barriers wrapped in the above DLL.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
static void cancel_wrappers(struct Barrier *barrier)
Cancels all subcontroller barrier handles.
uint16_t status
See PRISM_STATUS_*-constants.
unsigned int num_wbarriers_inited
Number of wrapped barrier initialised so far.
#define LOG(kind,...)
Logging shorthand.
#define LOCAL_QUORUM_REACHED(barrier)
Test to see if local peers have reached the required quorum of a barrier.
char * name
The name of the barrier.
Wrapper around Barrier handle.
Barrier initialised successfully.
struct Barrier * barrier
The local barrier associated with the creation of this wrapper.
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
clsbarrier

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

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

Referenced by handle_barrier_init().

608 {
609  struct Barrier *barrier = cls;
610 
611  cancel_wrappers (barrier);
613  send_barrier_status_msg (barrier,
614  "Timedout while propagating barrier initialisation\n");
615  remove_barrier (barrier);
616 }
static void send_barrier_status_msg(struct Barrier *barrier, const char *emsg)
Sends a barrier failed message.
enum GNUNET_TESTBED_BarrierStatus status
The status of this barrier.
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...
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
clsidentification of the client
msgthe actual message
Returns
GNUNET_OK if msg is well-formed

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

References GNUNET_OK.

629 {
630  return GNUNET_OK; /* always well-formed */
631 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75

◆ 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
clsidentification of the client
msgthe actual message

Definition at line 646 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.

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;
658 
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 (
729  "Sending GNUNET_TESTBED_BARRIERSTATUS_INITIALISED for barrier `%s'\n",
730  barrier->name);
731  send_barrier_status_msg (barrier, NULL);
732  }
733  else
735  30),
737  barrier);
738 }
struct WBarrier * wtail
DLL tail for the list of barrier handles.
static struct GNUNET_CONTAINER_MultiHashMap * barrier_map
Hashtable handle for storing initialised barriers.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Structure representing a connected(directly-linked) controller.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
int 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)...
static void send_barrier_status_msg(struct Barrier *barrier, const char *emsg)
Sends a barrier failed message.
struct GNUNET_TESTBED_Barrier * hbarrier
The barrier handle from API.
enum GNUNET_TESTBED_BarrierStatus status
The status of this barrier.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
unsigned int num_wbarriers
Number of barriers wrapped in the above DLL.
Handle to a client that is connected to a service.
Definition: service.c:250
#define MESSAGE_SEND_TIMEOUT(s)
timeout for outgoing message transmissions in seconds
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:1253
, &#39; bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:48
struct WBarrier * whead
DLL head for the list of barrier handles.
struct GNUNET_SERVICE_Client * client
The client handle associated with this context.
struct GNUNET_TESTBED_Controller * controller
Handle to the slave controller where this wrapper creates a barrier.
A 512-bit hashcode.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2324
struct GNUNET_HashCode hash
The hashcode of the barrier name.
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:2370
struct GNUNET_SERVICE_Client * mc
The client handle to the master controller.
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT.
Definition: testbed.h:787
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
int 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.
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().
char * name
The name of the barrier.
uint8_t quorum
Quorum percentage to be reached.
const char * name
struct Context * GST_context
The master context; generated with the first INIT message.
struct GNUNET_SCHEDULER_Task * tout_task
Identifier for the timeout task.
Wrapper around Barrier handle.
uint8_t quorum
The quorum percentage needed for crossing the barrier.
Definition: testbed.h:792
static void fwd_tout_barrier_init(void *cls)
Function called upon timeout while waiting for a response from the subcontrollers to barrier init mes...
struct GNUNET_TESTBED_Controller * controller
The controller handle.
Barrier initialised successfully.
#define GNUNET_YES
Definition: gnunet_common.h:77
char name[0]
name of the barrier.
Definition: testbed.h:797
Message to initialise a barrier.
Definition: testbed.h:782
struct Barrier * barrier
The local barrier associated with the creation of this wrapper.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
#define LOG_DEBUG(...)
Debug logging shorthand.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
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.
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
clsidentification of the client
msgthe actual message
Returns
GNUNET_OK if msg is well-formed

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

References GNUNET_OK.

751 {
752  return GNUNET_OK; /* all are well-formed */
753 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75

◆ 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
clsidentification of the client
msgthe actual message

Definition at line 768 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.

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;
777 
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);
793  GNUNET_memcpy (name,
794  msg->name,
795  name_len);
796  LOG_DEBUG ("Received BARRIER_CANCEL for barrier `%s'\n",
797  name);
798  GNUNET_CRYPTO_hash (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 }
Message to cancel a barrier.
Definition: testbed.h:804
static struct GNUNET_CONTAINER_MultiHashMap * barrier_map
Hashtable handle for storing initialised barriers.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
int 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)...
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL.
Definition: testbed.h:809
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.
Handle to a client that is connected to a service.
Definition: service.c:250
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:48
static void cancel_wrappers(struct Barrier *barrier)
Cancels all subcontroller barrier handles.
struct GNUNET_SERVICE_Client * client
The client handle associated with this context.
char name[0]
The barrier name.
Definition: testbed.h:814
A 512-bit hashcode.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2324
const char * name
struct Context * GST_context
The master context; generated with the first INIT message.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
#define LOG_DEBUG(...)
Debug logging shorthand.
static void remove_barrier(struct Barrier *barrier)
Function to remove a barrier from the barrier map and cleanup resources occupied by a barrier...
#define GNUNET_malloc(size)
Wrapper around malloc.
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
clsidentification of the client
msgthe actual message
Returns
GNUNET_OK if msg is well-formed

Definition at line 826 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.

828 {
829  uint16_t msize;
830  uint16_t name_len;
831  const char *name;
833 
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 name_len
strlen of the barrier name
Definition: testbed.h:836
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS.
Definition: testbed.h:826
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
GNUNET_TESTBED_BarrierStatus
Status of a barrier.
uint16_t status
status.
Definition: testbed.h:831
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
uint16_t status
See PRISM_STATUS_*-constants.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
char data[0]
the barrier name (0-terminated) concatenated with an error message (0-terminated) if the status were ...
Definition: testbed.h:842
const char * name

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

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.

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;
878 
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);
895  GNUNET_CRYPTO_hash (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 * GNUNET_MQ_msg_copy(const struct GNUNET_MessageHeader *hdr)
Create a new envelope by copying an existing message.
Definition: mq.c:653
struct WBarrier * next
DLL next pointer.
Context to be associated with each client.
static struct GNUNET_CONTAINER_MultiHashMap * barrier_map
Hashtable handle for storing initialised barriers.
uint16_t name_len
strlen of the barrier name
Definition: testbed.h:836
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2437
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS.
Definition: testbed.h:826
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.
Handle to a client that is connected to a service.
Definition: service.c:250
struct ClientCtx * next
DLL next ptr.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:48
struct WBarrier * whead
DLL head for the list of barrier handles.
struct GNUNET_SERVICE_Client * client
The client handle associated with this context.
struct GNUNET_TESTBED_Controller * controller
Handle to the slave controller where this wrapper creates a barrier.
A 512-bit hashcode.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2324
struct GNUNET_HashCode key
The key used in the DHT.
char data[0]
the barrier name (0-terminated) concatenated with an error message (0-terminated) if the status were ...
Definition: testbed.h:842
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:1335
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_SERVICE_Client * client
The client handle.
const char * name
struct Context * GST_context
The master context; generated with the first INIT message.
struct ClientCtx * head
DLL head for the list of clients waiting for this barrier.
Wrapper around Barrier handle.
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:353
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
#define LOG_DEBUG(...)
Debug logging shorthand.
struct GNUNET_MessageHeader * GNUNET_copy_message(const struct GNUNET_MessageHeader *msg)
Create a copy of the given message.
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 212 of file gnunet-service-testbed_barriers.c.

◆ ctx

struct GNUNET_SERVICE_Handle* ctx
static

Service context.

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

Referenced by remove_barrier().