GNUnet  0.19.2
gnunet-service-testbed_barriers.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2008--2016 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
20 
27 #include "platform.h"
28 #include "gnunet-service-testbed.h"
30 #include "testbed_api.h"
31 
32 
36 #define MESSAGE_SEND_TIMEOUT(s) \
37  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, s)
38 
39 
43 #define LOCAL_QUORUM_REACHED(barrier) \
44  ((barrier->quorum * GST_num_local_peers) <= (barrier->nreached * 100))
45 
46 
47 #ifdef LOG
48 #undef LOG
49 #endif
50 
54 #define LOG(kind, ...) \
55  GNUNET_log_from (kind, "testbed-barriers", __VA_ARGS__)
56 
57 
61 struct Barrier;
62 
63 
67 struct ClientCtx
68 {
72  struct Barrier *barrier;
73 
77  struct ClientCtx *next;
78 
82  struct ClientCtx *prev;
83 
88 };
89 
90 
94 struct WBarrier
95 {
99  struct WBarrier *next;
100 
104  struct WBarrier *prev;
105 
109  struct Barrier *barrier;
110 
115 
120 
124  uint8_t reached;
125 };
126 
127 
131 struct Barrier
132 {
136  struct GNUNET_HashCode hash;
137 
142 
146  char *name;
147 
151  struct ClientCtx *head;
152 
156  struct ClientCtx *tail;
157 
161  struct WBarrier *whead;
162 
166  struct WBarrier *wtail;
167 
172 
177 
181  unsigned int num_wbarriers;
182 
186  unsigned int num_wbarriers_reached;
187 
191  unsigned int num_wbarriers_inited;
192 
196  unsigned int nreached;
197 
201  unsigned int nslaves;
202 
206  uint8_t quorum;
207 };
208 
209 
214 
218 static struct GNUNET_SERVICE_Handle *ctx;
219 
220 
227 static void
228 remove_barrier (struct Barrier *barrier)
229 {
230  struct ClientCtx *ctx;
231 
234  &barrier->hash,
235  barrier));
236  while (NULL != (ctx = barrier->head))
237  {
239  barrier->tail,
240  ctx);
241  ctx->barrier = NULL;
242  }
245 }
246 
247 
253 static void
255 {
256  struct WBarrier *wrapper;
257 
258  while (NULL != (wrapper = barrier->whead))
259  {
262  barrier->wtail,
263  wrapper);
264  GNUNET_free (wrapper);
265  }
266 }
267 
268 
278 static void
280  const char *name,
282  const char *emsg)
283 {
284  struct GNUNET_MQ_Envelope *env;
286  size_t name_len;
287  size_t err_len;
288 
289  GNUNET_assert ((NULL == emsg) ||
291  name_len = strlen (name) + 1;
292  err_len = ((NULL == emsg) ? 0 : (strlen (emsg) + 1));
294  name_len + err_len,
296  msg->status = htons (status);
297  msg->name_len = htons ((uint16_t) name_len - 1);
298  GNUNET_memcpy (msg->data,
299  name,
300  name_len);
301  GNUNET_memcpy (msg->data + name_len,
302  emsg,
303  err_len);
305  env);
306 }
307 
308 
316 static void
318  const char *emsg)
319 {
320  GNUNET_assert (0 != barrier->status);
321  send_client_status_msg (barrier->mc,
322  barrier->name,
323  barrier->status,
324  emsg);
325 }
326 
327 
334 static int
336  const struct GNUNET_TESTBED_BarrierWait *msg)
337 {
338  return GNUNET_OK; /* always well-formed */
339 }
340 
341 
353 static void
355  const struct GNUNET_TESTBED_BarrierWait *msg)
356 {
357  struct ClientCtx *client_ctx = cls;
358  struct Barrier *barrier;
359  char *name;
360  struct GNUNET_HashCode key;
361  size_t name_len;
362  uint16_t msize;
363 
364  msize = ntohs (msg->header.size);
365  if (NULL == barrier_map)
366  {
367  GNUNET_break (0);
368  GNUNET_SERVICE_client_drop (client_ctx->client);
369  return;
370  }
371  name_len = msize - sizeof(struct GNUNET_TESTBED_BarrierWait);
372  name = GNUNET_malloc (name_len + 1);
373  name[name_len] = '\0';
375  msg->name,
376  name_len);
377  LOG_DEBUG ("Received BARRIER_WAIT for barrier `%s'\n",
378  name);
380  name_len,
381  &key);
382  GNUNET_free (name);
383  if (NULL == (barrier = GNUNET_CONTAINER_multihashmap_get (barrier_map, &key)))
384  {
385  GNUNET_break (0);
386  GNUNET_SERVICE_client_drop (client_ctx->client);
387  return;
388  }
389  if (NULL != client_ctx->barrier)
390  {
391  GNUNET_break (0);
392  GNUNET_SERVICE_client_drop (client_ctx->client);
393  return;
394  }
395  client_ctx->barrier = barrier;
397  barrier->tail,
398  client_ctx);
399  barrier->nreached++;
400  if ((barrier->num_wbarriers_reached == barrier->num_wbarriers) &&
401  (LOCAL_QUORUM_REACHED (barrier)))
402  {
404  send_barrier_status_msg (barrier,
405  NULL);
406  }
408 }
409 
410 
419 static void *
420 connect_cb (void *cls,
421  struct GNUNET_SERVICE_Client *client,
422  struct GNUNET_MQ_Handle *mq)
423 {
424  struct ClientCtx *client_ctx;
425 
426  LOG_DEBUG ("Client connected to testbed-barrier service\n");
427  client_ctx = GNUNET_new (struct ClientCtx);
428  client_ctx->client = client;
429  return client_ctx;
430 }
431 
432 
441 static void
442 disconnect_cb (void *cls,
444  void *app_ctx)
445 {
446  struct ClientCtx *client_ctx = app_ctx;
447  struct Barrier *barrier = client_ctx->barrier;
448 
449  if (NULL != barrier)
450  {
452  barrier->tail,
453  client_ctx);
454  client_ctx->barrier = NULL;
455  }
456  GNUNET_free (client_ctx);
457  LOG_DEBUG ("Client disconnected from testbed-barrier service\n");
458 }
459 
460 
466 void
468 {
469  struct GNUNET_MQ_MessageHandler message_handlers[] = {
470  GNUNET_MQ_hd_var_size (barrier_wait,
473  NULL),
475  };
476 
477  LOG_DEBUG ("Launching testbed-barrier service\n");
479  GNUNET_YES);
480  ctx = GNUNET_SERVICE_start ("testbed-barrier",
481  cfg,
482  &connect_cb,
483  &disconnect_cb,
484  NULL,
485  message_handlers);
486 }
487 
488 
499 static int
501  const struct GNUNET_HashCode *key,
502  void *value)
503 {
504  struct Barrier *barrier = value;
505 
506  GNUNET_assert (NULL != barrier);
507  cancel_wrappers (barrier);
508  remove_barrier (barrier);
509  return GNUNET_YES;
510 }
511 
512 
516 void
518 {
519  GNUNET_assert (NULL != barrier_map);
522  &
524  NULL));
526  GNUNET_assert (NULL != ctx);
528 }
529 
530 
544 static void
546  const char *name,
547  struct GNUNET_TESTBED_Barrier *b_,
549  const char *emsg)
550 {
551  struct WBarrier *wrapper = cls;
552  struct Barrier *barrier = wrapper->barrier;
553 
554  GNUNET_assert (b_ == wrapper->hbarrier);
555  switch (status)
556  {
559  "Initialising barrier `%s' failed at a sub-controller: %s\n",
560  barrier->name,
561  (NULL != emsg) ? emsg : "NULL");
562  cancel_wrappers (barrier);
563  if (NULL == emsg)
564  emsg = "Initialisation failed at a sub-controller";
566  send_barrier_status_msg (barrier, emsg);
567  return;
568 
571  {
572  GNUNET_break_op (0);
573  return;
574  }
575  barrier->num_wbarriers_reached++;
576  if ((barrier->num_wbarriers_reached == barrier->num_wbarriers)
577  && (LOCAL_QUORUM_REACHED (barrier)))
578  {
580  send_barrier_status_msg (barrier, NULL);
581  }
582  return;
583 
585  if (0 != barrier->status)
586  {
587  GNUNET_break_op (0);
588  return;
589  }
590  barrier->num_wbarriers_inited++;
591  if (barrier->num_wbarriers_inited == barrier->num_wbarriers)
592  {
594  send_barrier_status_msg (barrier, NULL);
595  }
596  return;
597  }
598 }
599 
600 
607 static void
609 {
610  struct Barrier *barrier = cls;
611 
612  cancel_wrappers (barrier);
614  send_barrier_status_msg (barrier,
615  "Timedout while propagating barrier initialisation\n");
616  remove_barrier (barrier);
617 }
618 
619 
627 int
629  const struct GNUNET_TESTBED_BarrierInit *msg)
630 {
631  return GNUNET_OK; /* always well-formed */
632 }
633 
634 
646 void
648  const struct GNUNET_TESTBED_BarrierInit *msg)
649 {
650  struct GNUNET_SERVICE_Client *client = cls;
651  char *name;
652  struct Barrier *barrier;
653  struct Slave *slave;
654  struct WBarrier *wrapper;
655  struct GNUNET_HashCode hash;
656  size_t name_len;
657  unsigned int cnt;
658  uint16_t msize;
659 
660  if (NULL == GST_context)
661  {
662  GNUNET_break_op (0);
664  return;
665  }
666  if (client != GST_context->client)
667  {
668  GNUNET_break_op (0);
670  return;
671  }
672  msize = ntohs (msg->header.size);
673  name_len = (size_t) msize - sizeof(struct GNUNET_TESTBED_BarrierInit);
674  name = GNUNET_malloc (name_len + 1);
675  GNUNET_memcpy (name, msg->name, name_len);
676  GNUNET_CRYPTO_hash (name, name_len, &hash);
677  LOG_DEBUG ("Received BARRIER_INIT for barrier `%s'\n",
678  name);
679  if (GNUNET_YES ==
681  &hash))
682  {
683  send_client_status_msg (client,
684  name,
686  "A barrier with the same name already exists");
687  GNUNET_free (name);
689  return;
690  }
691  barrier = GNUNET_new (struct Barrier);
692  barrier->hash = hash;
693  barrier->quorum = msg->quorum;
694  barrier->name = name;
695  barrier->mc = client;
698  &barrier->hash,
699  barrier,
702  /* Propagate barrier init to subcontrollers */
703  for (cnt = 0; cnt < GST_slave_list_size; cnt++)
704  {
705  if (NULL == (slave = GST_slave_list[cnt]))
706  continue;
707  if (NULL == slave->controller)
708  {
709  GNUNET_break (0); /* May happen when we are connecting to the controller */
710  continue;
711  }
712  wrapper = GNUNET_new (struct WBarrier);
713  wrapper->barrier = barrier;
714  wrapper->controller = slave->controller;
716  barrier->wtail,
717  wrapper);
718  barrier->num_wbarriers++;
719  wrapper->hbarrier = GNUNET_TESTBED_barrier_init_ (wrapper->controller,
720  barrier->name,
721  barrier->quorum,
723  wrapper,
724  GNUNET_NO);
725  }
726  if (NULL == barrier->whead) /* No further propagation */
727  {
729  LOG_DEBUG (
730  "Sending GNUNET_TESTBED_BARRIERSTATUS_INITIALISED for barrier `%s'\n",
731  barrier->name);
732  send_barrier_status_msg (barrier, NULL);
733  }
734  else
736  30),
738  barrier);
739 }
740 
741 
749 int
751  const struct GNUNET_TESTBED_BarrierCancel *msg)
752 {
753  return GNUNET_OK; /* all are well-formed */
754 }
755 
756 
768 void
770  const struct GNUNET_TESTBED_BarrierCancel *msg)
771 {
772  struct GNUNET_SERVICE_Client *client = cls;
773  char *name;
774  struct Barrier *barrier;
775  struct GNUNET_HashCode hash;
776  size_t name_len;
777  uint16_t msize;
778 
779  if (NULL == GST_context)
780  {
781  GNUNET_break_op (0);
783  return;
784  }
785  if (client != GST_context->client)
786  {
787  GNUNET_break_op (0);
789  return;
790  }
791  msize = ntohs (msg->header.size);
792  name_len = msize - sizeof(struct GNUNET_TESTBED_BarrierCancel);
793  name = GNUNET_malloc (name_len + 1);
795  msg->name,
796  name_len);
797  LOG_DEBUG ("Received BARRIER_CANCEL for barrier `%s'\n",
798  name);
800  name_len,
801  &hash);
802  if (GNUNET_NO ==
804  &hash))
805  {
806  GNUNET_break_op (0);
807  GNUNET_free (name);
809  return;
810  }
812  &hash);
813  GNUNET_assert (NULL != barrier);
814  cancel_wrappers (barrier);
815  remove_barrier (barrier);
816  GNUNET_free (name);
818 }
819 
820 
828 int
830  const struct GNUNET_TESTBED_BarrierStatusMsg *msg)
831 {
832  uint16_t msize;
833  uint16_t name_len;
834  const char *name;
836 
837  msize = ntohs (msg->header.size) - sizeof(*msg);
838  status = ntohs (msg->status);
840  {
841  GNUNET_break_op (0); /* current we only expect BARRIER_CROSSED
842  status message this way */
843  return GNUNET_SYSERR;
844  }
845  name = msg->data;
846  name_len = ntohs (msg->name_len);
847  if ((name_len + 1) != msize)
848  {
849  GNUNET_break_op (0);
850  return GNUNET_SYSERR;
851  }
852  if ('\0' != name[name_len])
853  {
854  GNUNET_break_op (0);
855  return GNUNET_SYSERR;
856  }
857  return GNUNET_OK;
858 }
859 
860 
869 void
871  const struct GNUNET_TESTBED_BarrierStatusMsg *msg)
872 {
873  struct GNUNET_SERVICE_Client *client = cls;
874  struct Barrier *barrier;
875  struct ClientCtx *client_ctx;
876  struct WBarrier *wrapper;
877  const char *name;
878  struct GNUNET_HashCode key;
879  uint16_t name_len;
880  struct GNUNET_MQ_Envelope *env;
881 
882  if (NULL == GST_context)
883  {
884  GNUNET_break_op (0);
886  return;
887  }
888  if (client != GST_context->client)
889  {
890  GNUNET_break_op (0);
892  return;
893  }
894  name = msg->data;
895  name_len = ntohs (msg->name_len);
896  LOG_DEBUG ("Received BARRIER_STATUS for barrier `%s'\n",
897  name);
899  name_len,
900  &key);
902  &key);
903  if (NULL == barrier)
904  {
905  GNUNET_break_op (0);
907  return;
908  }
910  for (client_ctx = barrier->head; NULL != client_ctx; client_ctx =
911  client_ctx->next) /* Notify peers */
912  {
913  env = GNUNET_MQ_msg_copy (&msg->header);
915  env);
916  }
921  for (wrapper = barrier->whead; NULL != wrapper; wrapper = wrapper->next)
922  {
924  GNUNET_copy_message (&msg->header));
925  }
926 }
927 
928 
929 /* end of gnunet-service-testbed_barriers.c */
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
struct GNUNET_HashCode key
The key used in the DHT.
uint16_t status
See PRISM_STATUS_*-constants.
static char * value
Value of the record to add/remove.
#define LOG_DEBUG(...)
Debug logging shorthand.
struct Context * GST_context
The master context; generated with the first INIT message.
data structures shared amongst components of TESTBED service
#define MESSAGE_SEND_TIMEOUT(s)
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().
#define LOCAL_QUORUM_REACHED(barrier)
Test to see if local peers have reached the required quorum of a barrier.
int check_barrier_init(void *cls, const struct GNUNET_TESTBED_BarrierInit *msg)
Check GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT messages.
void handle_barrier_cancel(void *cls, const struct GNUNET_TESTBED_BarrierCancel *msg)
Message handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL messages.
void handle_barrier_init(void *cls, const struct GNUNET_TESTBED_BarrierInit *msg)
Message handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT messages.
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 handle_barrier_wait(void *cls, const struct GNUNET_TESTBED_BarrierWait *msg)
Message handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT messages.
static void cancel_wrappers(struct Barrier *barrier)
Cancels all subcontroller barrier handles.
static int check_barrier_wait(void *cls, const struct GNUNET_TESTBED_BarrierWait *msg)
Check GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT messages.
int check_barrier_status(void *cls, const struct GNUNET_TESTBED_BarrierStatusMsg *msg)
Check GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS messages.
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 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.
void GST_barriers_init(struct GNUNET_CONFIGURATION_Handle *cfg)
Function to initialise barriers component.
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 int barrier_destroy_iterator(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator over hash map entries.
static void remove_barrier(struct Barrier *barrier)
Function to remove a barrier from the barrier map and cleanup resources occupied by a barrier.
int check_barrier_cancel(void *cls, const struct GNUNET_TESTBED_BarrierCancel *msg)
Check GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL messages.
void GST_barriers_destroy()
Function to stop the barrier service.
void handle_barrier_status(void *cls, const struct GNUNET_TESTBED_BarrierStatusMsg *msg)
Message handler for GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS messages.
#define LOG(kind,...)
Logging shorthand.
static struct GNUNET_CONTAINER_MultiHashMap * barrier_map
Hashtable handle for storing initialised barriers.
static void send_barrier_status_msg(struct Barrier *barrier, const char *emsg)
Sends a barrier failed message.
Interface for the barrier initialisation handler routine.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#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_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
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.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
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.
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.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...
void * cls
Closure for mv and cb.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_ERROR
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
struct GNUNET_MessageHeader * GNUNET_copy_message(const struct GNUNET_MessageHeader *msg)
Create a copy of the given message.
#define GNUNET_free(ptr)
Wrapper around free.
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:304
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#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:62
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
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:533
#define GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS
Message for signalling status of a barrier.
#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_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:1241
void GNUNET_SERVICE_stop(struct GNUNET_SERVICE_Handle *srv)
Stops a service that was started with GNUNET_SERVICE_start().
Definition: service.c:1913
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2330
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2443
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:1880
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2249
GNUNET_TESTBED_BarrierStatus
Status of a barrier.
void GNUNET_TESTBED_barrier_cancel(struct GNUNET_TESTBED_Barrier *barrier)
Cancel a barrier.
Definition: testbed_api.c:2412
@ GNUNET_TESTBED_BARRIERSTATUS_CROSSED
Barrier is crossed.
@ GNUNET_TESTBED_BARRIERSTATUS_ERROR
Error status.
@ GNUNET_TESTBED_BARRIERSTATUS_INITIALISED
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_reached
Number of wrapped barriers reached so far.
unsigned int num_wbarriers
Number of barriers wrapped in the above DLL.
unsigned int nreached
Number of peers which have reached this barrier.
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 ClientCtx * head
DLL head for the list of clients waiting for this barrier.
unsigned int num_wbarriers_inited
Number of wrapped barrier initialised so far.
struct ClientCtx * tail
DLL tail for the list of clients waiting for this barrier.
unsigned int nslaves
Number of slaves we have initialised this barrier.
struct GNUNET_SERVICE_Client * mc
The client handle to the master controller.
Context to be associated with each client.
struct ClientCtx * next
DLL next ptr.
struct Barrier * barrier
The barrier this client is waiting for.
struct GNUNET_SERVICE_Client * client
The client handle.
struct ClientCtx * prev
DLL prev ptr.
struct GNUNET_SERVICE_Client * client
The client handle associated with this context.
Internal representation of the hash map.
A 512-bit hashcode.
Handle to a message queue.
Definition: mq.c:87
Message handler for a specific message type.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Entry in list of pending tasks.
Definition: scheduler.c:136
Handle to a client that is connected to a service.
Definition: service.c:252
Handle to a service.
Definition: service.c:118
Message to cancel a barrier.
Definition: testbed.h:805
Message to initialise a barrier.
Definition: testbed.h:783
Message for signalling status changes of a barrier.
Definition: testbed.h:822
uint16_t name_len
strlen of the barrier name
Definition: testbed.h:836
Message sent from peers to the testbed-barrier service to indicate that they have reached a barrier a...
Definition: testbed.h:851
Handle for barrier.
Definition: testbed_api.h:278
Handle to interact with a GNUnet testbed controller.
Definition: testbed_api.h:194
Structure representing a connected(directly-linked) controller.
struct GNUNET_TESTBED_Controller * controller
The controller handle.
Wrapper around Barrier handle.
uint8_t reached
Has this barrier been crossed?
struct Barrier * barrier
The local barrier associated with the creation of this wrapper.
struct WBarrier * next
DLL next pointer.
struct GNUNET_TESTBED_Barrier * hbarrier
The barrier handle from API.
struct WBarrier * prev
DLL prev pointer.
struct GNUNET_TESTBED_Controller * controller
Handle to the slave controller where this wrapper creates a barrier.
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
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:2324
Interface for functions internally exported from testbed_api.c.