src/testbed/gnunet-service-testbed_barriers.c

   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
  19 /**
  20  * @file testbed/gnunet-service-testbed_barriers.c
  21  * @brief barrier handling at the testbed controller
  22  * @author Sree Harsha Totakura <sreeharsha@totakura.in>
  23  */
  24
  25 #include "gnunet-service-testbed.h"
  26 #include "gnunet-service-testbed_barriers.h"
  27 #include "testbed_api.h"
  28
  29
  30 /**
  31  * timeout for outgoing message transmissions in seconds
  32  */
  33 #define MESSAGE_SEND_TIMEOUT(s) \
  34   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, s)
  35
  36
  37 /**
  38  * Test to see if local peers have reached the required quorum of a barrier
  39  */
  40 #define LOCAL_QUORUM_REACHED(barrier)           \
  41   ((barrier->quorum * GST_num_local_peers) <= (barrier->nreached * 100))
  42
  43
  44 #ifdef LOG
  45 #undef LOG
  46 #endif
  47
  48 /**
  49  * Logging shorthand
  50  */
  51 #define LOG(kind,...)                                           \
  52   GNUNET_log_from (kind, "testbed-barriers", __VA_ARGS__)
  53
  54
  55 /**
  56  * Barrier
  57  */
  58 struct Barrier;
  59
  60
  61 /**
  62  * Context to be associated with each client
  63  */
  64 struct ClientCtx
  65 {
  66   /**
  67    * The barrier this client is waiting for
  68    */
  69   struct Barrier *barrier;
  70
  71   /**
  72    * DLL next ptr
  73    */
  74   struct ClientCtx *next;
  75
  76   /**
  77    * DLL prev ptr
  78    */
  79   struct ClientCtx *prev;
  80
  81   /**
  82    * The client handle
  83    */
  84   struct GNUNET_SERVICE_Client *client;
  85
  86 };
  87
  88
  89 /**
  90  * Wrapper around Barrier handle
  91  */
  92 struct WBarrier
  93 {
  94   /**
  95    * DLL next pointer
  96    */
  97   struct WBarrier *next;
  98
  99   /**
 100    * DLL prev pointer
 101    */
 102   struct WBarrier *prev;
 103
 104   /**
 105    * The local barrier associated with the creation of this wrapper
 106    */
 107   struct Barrier *barrier;
 108
 109   /**
 110    * Handle to the slave controller where this wrapper creates a barrier
 111    */
 112   struct GNUNET_TESTBED_Controller *controller;
 113
 114   /**
 115    * The barrier handle from API
 116    */
 117   struct GNUNET_TESTBED_Barrier *hbarrier;
 118
 119   /**
 120    * Has this barrier been crossed?
 121    */
 122   uint8_t reached;
 123 };
 124
 125
 126 /**
 127  * Barrier
 128  */
 129 struct Barrier
 130 {
 131   /**
 132    * The hashcode of the barrier name
 133    */
 134   struct GNUNET_HashCode hash;
 135
 136   /**
 137    * The client handle to the master controller
 138    */
 139   struct GNUNET_SERVICE_Client *mc;
 140
 141   /**
 142    * The name of the barrier
 143    */
 144   char *name;
 145
 146   /**
 147    * DLL head for the list of clients waiting for this barrier
 148    */
 149   struct ClientCtx *head;
 150
 151   /**
 152    * DLL tail for the list of clients waiting for this barrier
 153    */
 154   struct ClientCtx *tail;
 155
 156   /**
 157    * DLL head for the list of barrier handles
 158    */
 159   struct WBarrier *whead;
 160
 161   /**
 162    * DLL tail for the list of barrier handles
 163    */
 164   struct WBarrier *wtail;
 165
 166   /**
 167    * Identifier for the timeout task
 168    */
 169   struct GNUNET_SCHEDULER_Task *tout_task;
 170
 171   /**
 172    * The status of this barrier
 173    */
 174   enum GNUNET_TESTBED_BarrierStatus status;
 175
 176   /**
 177    * Number of barriers wrapped in the above DLL
 178    */
 179   unsigned int num_wbarriers;
 180
 181   /**
 182    * Number of wrapped barriers reached so far
 183    */
 184   unsigned int num_wbarriers_reached;
 185
 186   /**
 187    * Number of wrapped barrier initialised so far
 188    */
 189   unsigned int num_wbarriers_inited;
 190
 191   /**
 192    * Number of peers which have reached this barrier
 193    */
 194   unsigned int nreached;
 195
 196   /**
 197    * Number of slaves we have initialised this barrier
 198    */
 199   unsigned int nslaves;
 200
 201   /**
 202    * Quorum percentage to be reached
 203    */
 204   uint8_t quorum;
 205
 206 };
 207
 208
 209 /**
 210  * Hashtable handle for storing initialised barriers
 211  */
 212 static struct GNUNET_CONTAINER_MultiHashMap *barrier_map;
 213
 214 /**
 215  * Service context
 216  */
 217 static struct GNUNET_SERVICE_Handle *ctx;
 218
 219
 220 /**
 221  * Function to remove a barrier from the barrier map and cleanup resources
 222  * occupied by a barrier
 223  *
 224  * @param barrier the barrier handle
 225  */
 226 static void
 227 remove_barrier (struct Barrier *barrier)
 228 {
 229   struct ClientCtx *ctx;
 230
 231   GNUNET_assert (GNUNET_YES ==
 232                  GNUNET_CONTAINER_multihashmap_remove (barrier_map,
 233                                                        &barrier->hash,
 234                                                        barrier));
 235   while (NULL != (ctx = barrier->head))
 236   {
 237     GNUNET_CONTAINER_DLL_remove (barrier->head,
 238                                  barrier->tail,
 239                                  ctx);
 240     ctx->barrier = NULL;
 241   }
 242   GNUNET_free (barrier->name);
 243   GNUNET_free (barrier);
 244 }
 245
 246
 247 /**
 248  * Cancels all subcontroller barrier handles
 249  *
 250  * @param barrier the local barrier
 251  */
 252 static void
 253 cancel_wrappers (struct Barrier *barrier)
 254 {
 255   struct WBarrier *wrapper;
 256
 257   while (NULL != (wrapper = barrier->whead))
 258   {
 259     GNUNET_TESTBED_barrier_cancel (wrapper->hbarrier);
 260     GNUNET_CONTAINER_DLL_remove (barrier->whead,
 261                                  barrier->wtail,
 262                                  wrapper);
 263     GNUNET_free (wrapper);
 264   }
 265 }
 266
 267
 268 /**
 269  * Send a status message about a barrier to the given client
 270  *
 271  * @param client the client to send the message to
 272  * @param name the barrier name
 273  * @param status the status of the barrier
 274  * @param emsg the error message; should be non-NULL for
 275  *   status=GNUNET_TESTBED_BARRIERSTATUS_ERROR
 276  */
 277 static void
 278 send_client_status_msg (struct GNUNET_SERVICE_Client *client,
 279                         const char *name,
 280                         enum GNUNET_TESTBED_BarrierStatus status,
 281                         const char *emsg)
 282 {
 283   struct GNUNET_MQ_Envelope *env;
 284   struct GNUNET_TESTBED_BarrierStatusMsg *msg;
 285   size_t name_len;
 286   size_t err_len;
 287
 288   GNUNET_assert ( (NULL == emsg) ||
 289                   (GNUNET_TESTBED_BARRIERSTATUS_ERROR == status) );
 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,
 294                              GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS);
 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);
 303   GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
 304                   env);
 305 }
 306
 307
 308 /**
 309  * Sends a barrier failed message
 310  *
 311  * @param barrier the corresponding barrier
 312  * @param emsg the error message; should be non-NULL for
 313  *   status=GNUNET_TESTBED_BARRIERSTATUS_ERROR
 314  */
 315 static void
 316 send_barrier_status_msg (struct Barrier *barrier,
 317                          const char *emsg)
 318 {
 319   GNUNET_assert (0 != barrier->status);
 320   send_client_status_msg (barrier->mc,
 321                           barrier->name,
 322                           barrier->status,
 323                           emsg);
 324 }
 325
 326
 327 /**
 328  * Check #GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT messages.
 329  *
 330  * @param cls identification of the client
 331  * @param message the actual message
 332  */
 333 static int
 334 check_barrier_wait (void *cls,
 335                      const struct GNUNET_TESTBED_BarrierWait *msg)
 336 {
 337   return GNUNET_OK; /* always well-formed */
 338 }
 339
 340
 341 /**
 342  * Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT messages.  This
 343  * message should come from peers or a shared helper service using the
 344  * testbed-barrier client API (@see gnunet_testbed_barrier_service.h)
 345  *
 346  * This handler is queued in the main service and will handle the messages sent
 347  * either from the testbed driver or from a high level controller
 348  *
 349  * @param cls identification of the client
 350  * @param message the actual message
 351  */
 352 static void
 353 handle_barrier_wait (void *cls,
 354                      const struct GNUNET_TESTBED_BarrierWait *msg)
 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;
 395   GNUNET_CONTAINER_DLL_insert_tail (barrier->head,
 396                                     barrier->tail,
 397                                     client_ctx);
 398   barrier->nreached++;
 399   if ( (barrier->num_wbarriers_reached == barrier->num_wbarriers) &&
 400        (LOCAL_QUORUM_REACHED (barrier)) )
 401   {
 402     barrier->status = GNUNET_TESTBED_BARRIERSTATUS_CROSSED;
 403     send_barrier_status_msg (barrier,
 404                              NULL);
 405   }
 406   GNUNET_SERVICE_client_continue (client_ctx->client);
 407 }
 408
 409
 410 /**
 411  * Function called when a client connects to the testbed-barrier service.
 412  *
 413  * @param cls NULL
 414  * @param client the connecting client
 415  * @param mq queue to talk to @a client
 416  * @return our `struct ClientCtx`
 417  */
 418 static void *
 419 connect_cb (void *cls,
 420             struct GNUNET_SERVICE_Client *client,
 421             struct GNUNET_MQ_Handle *mq)
 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 }
 430
 431
 432 /**
 433  * Functions with this signature are called whenever a client
 434  * is disconnected on the network level.
 435  *
 436  * @param cls closure
 437  * @param client identification of the client; NULL
 438  *        for the last call when the server is destroyed
 439  */
 440 static void
 441 disconnect_cb (void *cls,
 442                struct GNUNET_SERVICE_Client *client,
 443                void *app_ctx)
 444 {
 445   struct ClientCtx *client_ctx = app_ctx;
 446   struct Barrier *barrier = client_ctx->barrier;
 447
 448   if (NULL != barrier)
 449   {
 450     GNUNET_CONTAINER_DLL_remove (barrier->head,
 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 }
 458
 459
 460 /**
 461  * Function to initialise barrriers component
 462  *
 463  * @param cfg the configuration to use for initialisation
 464  */
 465 void
 466 GST_barriers_init (struct GNUNET_CONFIGURATION_Handle *cfg)
 467 {
 468   struct GNUNET_MQ_MessageHandler message_handlers[] = {
 469     GNUNET_MQ_hd_var_size (barrier_wait,
 470                            GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_WAIT,
 471                            struct GNUNET_TESTBED_BarrierWait,
 472                            NULL),
 473     GNUNET_MQ_handler_end ()
 474   };
 475
 476   LOG_DEBUG ("Launching testbed-barrier service\n");
 477   barrier_map = GNUNET_CONTAINER_multihashmap_create (3,
 478                                                       GNUNET_YES);
 479   ctx = GNUNET_SERVICE_start ("testbed-barrier",
 480                               cfg,
 481                               &connect_cb,
 482                               &disconnect_cb,
 483                               NULL,
 484                               message_handlers);
 485 }
 486
 487
 488 /**
 489  * Iterator over hash map entries.
 490  *
 491  * @param cls closure
 492  * @param key current key code
 493  * @param value value in the hash map
 494  * @return #GNUNET_YES if we should continue to
 495  *         iterate,
 496  *         #GNUNET_NO if not.
 497  */
 498 static int
 499 barrier_destroy_iterator (void *cls,
 500                           const struct GNUNET_HashCode *key,
 501                           void *value)
 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 }
 510
 511
 512 /**
 513  * Function to stop the barrier service
 514  */
 515 void
 516 GST_barriers_destroy ()
 517 {
 518   GNUNET_assert (NULL != barrier_map);
 519   GNUNET_assert (GNUNET_SYSERR !=
 520                  GNUNET_CONTAINER_multihashmap_iterate (barrier_map,
 521                                                         &barrier_destroy_iterator,
 522                                                         NULL));
 523   GNUNET_CONTAINER_multihashmap_destroy (barrier_map);
 524   GNUNET_assert (NULL != ctx);
 525   GNUNET_SERVICE_stop (ctx);
 526 }
 527
 528
 529 /**
 530  * Functions of this type are to be given as callback argument to
 531  * GNUNET_TESTBED_barrier_init().  The callback will be called when status
 532  * information is available for the barrier.
 533  *
 534  * @param cls the closure given to GNUNET_TESTBED_barrier_init()
 535  * @param name the name of the barrier
 536  * @param b_ the barrier handle
 537  * @param status status of the barrier; #GNUNET_OK if the barrier is crossed;
 538  *   #GNUNET_SYSERR upon error
 539  * @param emsg if the status were to be #GNUNET_SYSERR, this parameter has the
 540  *   error messsage
 541  */
 542 static void
 543 wbarrier_status_cb (void *cls,
 544                     const char *name,
 545                     struct GNUNET_TESTBED_Barrier *b_,
 546                     enum GNUNET_TESTBED_BarrierStatus status,
 547                     const char *emsg)
 548 {
 549   struct WBarrier *wrapper = cls;
 550   struct Barrier *barrier = wrapper->barrier;
 551
 552   GNUNET_assert (b_ == wrapper->hbarrier);
 553   switch (status)
 554   {
 555   case GNUNET_TESTBED_BARRIERSTATUS_ERROR:
 556     LOG (GNUNET_ERROR_TYPE_ERROR,
 557          "Initialising barrier `%s' failed at a sub-controller: %s\n",
 558          barrier->name,
 559          (NULL != emsg) ? emsg : "NULL");
 560     cancel_wrappers (barrier);
 561     if (NULL == emsg)
 562       emsg = "Initialisation failed at a sub-controller";
 563     barrier->status = GNUNET_TESTBED_BARRIERSTATUS_ERROR;
 564     send_barrier_status_msg (barrier, emsg);
 565     return;
 566   case GNUNET_TESTBED_BARRIERSTATUS_CROSSED:
 567     if (GNUNET_TESTBED_BARRIERSTATUS_INITIALISED != barrier->status)
 568     {
 569       GNUNET_break_op (0);
 570       return;
 571     }
 572     barrier->num_wbarriers_reached++;
 573     if ((barrier->num_wbarriers_reached == barrier->num_wbarriers)
 574         && (LOCAL_QUORUM_REACHED (barrier)))
 575     {
 576       barrier->status = GNUNET_TESTBED_BARRIERSTATUS_CROSSED;
 577       send_barrier_status_msg (barrier, NULL);
 578     }
 579     return;
 580   case GNUNET_TESTBED_BARRIERSTATUS_INITIALISED:
 581     if (0 != barrier->status)
 582     {
 583       GNUNET_break_op (0);
 584       return;
 585     }
 586     barrier->num_wbarriers_inited++;
 587     if (barrier->num_wbarriers_inited == barrier->num_wbarriers)
 588     {
 589       barrier->status = GNUNET_TESTBED_BARRIERSTATUS_INITIALISED;
 590       send_barrier_status_msg (barrier, NULL);
 591     }
 592     return;
 593   }
 594 }
 595
 596
 597 /**
 598  * Function called upon timeout while waiting for a response from the
 599  * subcontrollers to barrier init message
 600  *
 601  * @param cls barrier
 602  */
 603 static void
 604 fwd_tout_barrier_init (void *cls)
 605 {
 606   struct Barrier *barrier = cls;
 607
 608   cancel_wrappers (barrier);
 609   barrier->status = GNUNET_TESTBED_BARRIERSTATUS_ERROR;
 610   send_barrier_status_msg (barrier,
 611                            "Timedout while propagating barrier initialisation\n");
 612   remove_barrier (barrier);
 613 }
 614
 615
 616
 617 /**
 618  * Check #GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT messages.
 619  *
 620  * @param cls identification of the client
 621  * @param msg the actual message
 622  * @return #GNUNET_OK if @a msg is well-formed
 623  */
 624 int
 625 check_barrier_init (void *cls,
 626                     const struct GNUNET_TESTBED_BarrierInit *msg)
 627 {
 628   return GNUNET_OK; /* always well-formed */
 629 }
 630
 631
 632 /**
 633  * Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT messages.  This
 634  * message should always come from a parent controller or the testbed API if we
 635  * are the root controller.
 636  *
 637  * This handler is queued in the main service and will handle the messages sent
 638  * either from the testbed driver or from a high level controller
 639  *
 640  * @param cls identification of the client
 641  * @param msg the actual message
 642  */
 643 void
 644 handle_barrier_init (void *cls,
 645                      const struct GNUNET_TESTBED_BarrierInit *msg)
 646 {
 647   struct GNUNET_SERVICE_Client *client = cls;
 648   char *name;
 649   struct Barrier *barrier;
 650   struct Slave *slave;
 651   struct WBarrier *wrapper;
 652   struct GNUNET_HashCode hash;
 653   size_t name_len;
 654   unsigned int cnt;
 655   uint16_t msize;
 656
 657   if (NULL == GST_context)
 658   {
 659     GNUNET_break_op (0);
 660     GNUNET_SERVICE_client_drop (client);
 661     return;
 662   }
 663   if (client != GST_context->client)
 664   {
 665     GNUNET_break_op (0);
 666     GNUNET_SERVICE_client_drop (client);
 667     return;
 668   }
 669   msize = ntohs (msg->header.size);
 670   name_len = (size_t) msize - sizeof (struct GNUNET_TESTBED_BarrierInit);
 671   name = GNUNET_malloc (name_len + 1);
 672   GNUNET_memcpy (name, msg->name, name_len);
 673   GNUNET_CRYPTO_hash (name, name_len, &hash);
 674   LOG_DEBUG ("Received BARRIER_INIT for barrier `%s'\n",
 675              name);
 676   if (GNUNET_YES ==
 677       GNUNET_CONTAINER_multihashmap_contains (barrier_map,
 678                                               &hash))
 679   {
 680     send_client_status_msg (client,
 681                             name,
 682                             GNUNET_TESTBED_BARRIERSTATUS_ERROR,
 683                             "A barrier with the same name already exists");
 684     GNUNET_free (name);
 685     GNUNET_SERVICE_client_continue (client);
 686     return;
 687   }
 688   barrier = GNUNET_new (struct Barrier);
 689   barrier->hash = hash;
 690   barrier->quorum = msg->quorum;
 691   barrier->name = name;
 692   barrier->mc = client;
 693   GNUNET_assert (GNUNET_OK ==
 694                  GNUNET_CONTAINER_multihashmap_put (barrier_map,
 695                                                     &barrier->hash,
 696                                                     barrier,
 697                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
 698   GNUNET_SERVICE_client_continue (client);
 699   /* Propagate barrier init to subcontrollers */
 700   for (cnt = 0; cnt < GST_slave_list_size; cnt++)
 701   {
 702     if (NULL == (slave = GST_slave_list[cnt]))
 703       continue;
 704     if (NULL == slave->controller)
 705     {
 706       GNUNET_break (0);/* May happen when we are connecting to the controller */
 707       continue;
 708     }
 709     wrapper = GNUNET_new (struct WBarrier);
 710     wrapper->barrier = barrier;
 711     wrapper->controller = slave->controller;
 712     GNUNET_CONTAINER_DLL_insert_tail (barrier->whead,
 713                                       barrier->wtail,
 714                                       wrapper);
 715     barrier->num_wbarriers++;
 716     wrapper->hbarrier = GNUNET_TESTBED_barrier_init_ (wrapper->controller,
 717                                                       barrier->name,
 718                                                       barrier->quorum,
 719                                                       &wbarrier_status_cb,
 720                                                       wrapper,
 721                                                       GNUNET_NO);
 722   }
 723   if (NULL == barrier->whead)   /* No further propagation */
 724   {
 725     barrier->status = GNUNET_TESTBED_BARRIERSTATUS_INITIALISED;
 726     LOG_DEBUG ("Sending GNUNET_TESTBED_BARRIERSTATUS_INITIALISED for barrier `%s'\n",
 727                barrier->name);
 728     send_barrier_status_msg (barrier, NULL);
 729   }else
 730     barrier->tout_task = GNUNET_SCHEDULER_add_delayed (MESSAGE_SEND_TIMEOUT (30),
 731                                                        &fwd_tout_barrier_init,
 732                                                        barrier);
 733 }
 734
 735
 736 /**
 737  * Check #GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL messages.
 738  *
 739  * @param cls identification of the client
 740  * @param msg the actual message
 741  * @return #GNUNET_OK if @a msg is well-formed
 742  */
 743 int
 744 check_barrier_cancel (void *cls,
 745                       const struct GNUNET_TESTBED_BarrierCancel *msg)
 746 {
 747   return GNUNET_OK; /* all are well-formed */
 748 }
 749
 750
 751 /**
 752  * Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL messages.  This
 753  * message should always come from a parent controller or the testbed API if we
 754  * are the root controller.
 755  *
 756  * This handler is queued in the main service and will handle the messages sent
 757  * either from the testbed driver or from a high level controller
 758  *
 759  * @param cls identification of the client
 760  * @param msg the actual message
 761  */
 762 void
 763 handle_barrier_cancel (void *cls,
 764                        const struct GNUNET_TESTBED_BarrierCancel *msg)
 765 {
 766   struct GNUNET_SERVICE_Client *client = cls;
 767   char *name;
 768   struct Barrier *barrier;
 769   struct GNUNET_HashCode hash;
 770   size_t name_len;
 771   uint16_t msize;
 772
 773   if (NULL == GST_context)
 774   {
 775     GNUNET_break_op (0);
 776     GNUNET_SERVICE_client_drop (client);
 777     return;
 778   }
 779   if (client != GST_context->client)
 780   {
 781     GNUNET_break_op (0);
 782     GNUNET_SERVICE_client_drop (client);
 783     return;
 784   }
 785   msize = ntohs (msg->header.size);
 786   name_len = msize - sizeof (struct GNUNET_TESTBED_BarrierCancel);
 787   name = GNUNET_malloc (name_len + 1);
 788   GNUNET_memcpy (name,
 789                  msg->name,
 790                  name_len);
 791   LOG_DEBUG ("Received BARRIER_CANCEL for barrier `%s'\n",
 792              name);
 793   GNUNET_CRYPTO_hash (name,
 794                       name_len,
 795                       &hash);
 796   if (GNUNET_NO ==
 797       GNUNET_CONTAINER_multihashmap_contains (barrier_map,
 798                                               &hash))
 799   {
 800     GNUNET_break_op (0);
 801     GNUNET_SERVICE_client_drop (client);
 802     return;
 803   }
 804   barrier = GNUNET_CONTAINER_multihashmap_get (barrier_map,
 805                                                &hash);
 806   GNUNET_assert (NULL != barrier);
 807   cancel_wrappers (barrier);
 808   remove_barrier (barrier);
 809   GNUNET_SERVICE_client_continue (client);
 810 }
 811
 812
 813 /**
 814  * Check #GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS messages.
 815  *
 816  * @param cls identification of the client
 817  * @param msg the actual message
 818  * @return #GNUNET_OK if @a msg is well-formed
 819  */
 820 int
 821 check_barrier_status (void *cls,
 822                       const struct GNUNET_TESTBED_BarrierStatusMsg *msg)
 823 {
 824   uint16_t msize;
 825   uint16_t name_len;
 826   const char *name;
 827   enum GNUNET_TESTBED_BarrierStatus status;
 828
 829   msize = ntohs (msg->header.size) - sizeof (*msg);
 830   status = ntohs (msg->status);
 831   if (GNUNET_TESTBED_BARRIERSTATUS_CROSSED != status)
 832   {
 833     GNUNET_break_op (0);        /* current we only expect BARRIER_CROSSED
 834                                    status message this way */
 835     return GNUNET_SYSERR;
 836   }
 837   name = msg->data;
 838   name_len = ntohs (msg->name_len);
 839   if ((name_len + 1) != msize)
 840   {
 841     GNUNET_break_op (0);
 842     return GNUNET_SYSERR;
 843   }
 844   if ('\0' != name[name_len])
 845   {
 846     GNUNET_break_op (0);
 847     return GNUNET_SYSERR;
 848   }
 849   return GNUNET_OK;
 850 }
 851
 852
 853 /**
 854  * Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS messages.
 855  * This handler is queued in the main service and will handle the messages sent
 856  * either from the testbed driver or from a high level controller
 857  *
 858  * @param cls identification of the client
 859  * @param msg the actual message
 860  */
 861 void
 862 handle_barrier_status (void *cls,
 863                        const struct GNUNET_TESTBED_BarrierStatusMsg *msg)
 864 {
 865   struct GNUNET_SERVICE_Client *client = cls;
 866   struct Barrier *barrier;
 867   struct ClientCtx *client_ctx;
 868   struct WBarrier *wrapper;
 869   const char *name;
 870   struct GNUNET_HashCode key;
 871   uint16_t name_len;
 872   struct GNUNET_MQ_Envelope *env;
 873
 874   if (NULL == GST_context)
 875   {
 876     GNUNET_break_op (0);
 877     GNUNET_SERVICE_client_drop (client);
 878     return;
 879   }
 880   if (client != GST_context->client)
 881   {
 882     GNUNET_break_op (0);
 883     GNUNET_SERVICE_client_drop (client);
 884     return;
 885   }
 886   name = msg->data;
 887   name_len = ntohs (msg->name_len);
 888   LOG_DEBUG ("Received BARRIER_STATUS for barrier `%s'\n",
 889              name);
 890   GNUNET_CRYPTO_hash (name,
 891                       name_len,
 892                       &key);
 893   barrier = GNUNET_CONTAINER_multihashmap_get (barrier_map,
 894                                                &key);
 895   if (NULL == barrier)
 896   {
 897     GNUNET_break_op (0);
 898     GNUNET_SERVICE_client_drop (client);
 899     return;
 900   }
 901   GNUNET_SERVICE_client_continue (client);
 902   for(client_ctx = barrier->head; NULL != client_ctx; client_ctx = client_ctx->next) /* Notify peers */
 903   {
 904     env = GNUNET_MQ_msg_copy (&msg->header);
 905     GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client_ctx->client),
 906                     env);
 907   }
 908   /**
 909    * The wrapper barriers do not echo the barrier status, so we have to do it
 910    * here
 911    */
 912   for (wrapper = barrier->whead; NULL != wrapper; wrapper = wrapper->next)
 913   {
 914     GNUNET_TESTBED_queue_message_ (wrapper->controller,
 915                                    GNUNET_copy_message (&msg->header));
 916   }
 917 }
 918
 919 /* end of gnunet-service-testbed_barriers.c */