GNUnet  0.11.x
gnunet-service-testbed.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2008--2013, 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 "gnunet-service-testbed.h"
30 
31 /***********/
32 /* Globals */
33 /***********/
34 
39 
44 
49 
54 
59 
64 
69 
73 unsigned int GST_host_list_size;
74 
78 unsigned int GST_peer_list_size;
79 
80 
81 /***********************************/
82 /* Local definitions and variables */
83 /***********************************/
84 
88 static char *hostname;
89 
90 
98 static int
100 {
101  uint32_t host_id;
102 
103  host_id = GNUNET_TESTBED_host_get_id_ (host);
104  if (GST_host_list_size <= host_id)
106  if (NULL != GST_host_list[host_id])
107  {
108  LOG_DEBUG ("A host with id: %u already exists\n", host_id);
109  return GNUNET_SYSERR;
110  }
111  GST_host_list[host_id] = host;
112  return GNUNET_OK;
113 }
114 
115 
123 void
125  uint64_t operation_id,
126  const char *emsg)
127 {
128  struct GNUNET_MQ_Envelope *env;
130  uint16_t emsg_len;
131 
132  emsg_len = (NULL == emsg) ? 0 : strlen (emsg) + 1;
134  emsg_len,
136  msg->event_type = htonl (GNUNET_TESTBED_ET_OPERATION_FINISHED);
137  msg->operation_id = GNUNET_htonll (operation_id);
138  GNUNET_memcpy (&msg[1],
139  emsg,
140  emsg_len);
142  env);
143 }
144 
145 
152 void
154  uint64_t operation_id)
155 {
156  struct GNUNET_MQ_Envelope *env;
158 
159  env = GNUNET_MQ_msg (msg,
161  msg->operation_id = GNUNET_htonll (operation_id);
162  msg->event_type = htonl (GNUNET_TESTBED_ET_OPERATION_FINISHED);
164  env);
165 }
166 
167 
174 static void
175 hr_completion (void *cls,
176  const char *emsg);
177 
178 
185 static void
186 register_next_host (struct Slave *slave)
187 {
188  struct HostRegistration *hr;
189 
190  hr = slave->hr_dll_head;
191  GNUNET_assert (NULL != hr);
192  GNUNET_assert (NULL == slave->rhandle);
193  LOG (GNUNET_ERROR_TYPE_DEBUG, "Registering host %u at %u\n",
196  slave->rhandle
198  hr->host,
200  slave);
201 }
202 
203 
210 static void
211 hr_completion (void *cls,
212  const char *emsg)
213 {
214  struct Slave *slave = cls;
215  struct HostRegistration *hr;
216 
217  slave->rhandle = NULL;
218  hr = slave->hr_dll_head;
219  GNUNET_assert (NULL != hr);
221  "Registering host %u at %u successful\n",
225  slave->hr_dll_tail,
226  hr);
227  if (NULL != hr->cb)
228  hr->cb (hr->cb_cls,
229  emsg);
230  GNUNET_free (hr);
231  if (NULL != slave->hr_dll_head)
232  register_next_host (slave);
233 }
234 
235 
245 void
248  void *cb_cls,
249  struct GNUNET_TESTBED_Host *host)
250 {
251  struct HostRegistration *hr;
252  int call_register;
253 
255  "Queueing host registration for host %u at %u\n",
258  hr = GNUNET_new (struct HostRegistration);
259  hr->cb = cb;
260  hr->cb_cls = cb_cls;
261  hr->host = host;
262  call_register = (NULL == slave->hr_dll_head) ? GNUNET_YES : GNUNET_NO;
264  slave->hr_dll_tail,
265  hr);
266  if (GNUNET_YES == call_register)
267  register_next_host (slave);
268 }
269 
270 
277 void
279  const struct GNUNET_MessageHeader *msg)
280 {
281  struct ForwardedOperationContext *fopc = cls;
282  struct GNUNET_MQ_Envelope *env;
283 
284  LOG_DEBUG ("Relaying message with type: %u, size: %u\n",
285  ntohs (msg->type),
286  ntohs (msg->size));
289  env);
292  fopcq_tail,
293  fopc);
294  GNUNET_free (fopc);
295 }
296 
297 
303 void
305 {
306  struct ForwardedOperationContext *fopc = cls;
307 
308  fopc->timeout_task = NULL;
311  "A forwarded operation has timed out\n");
313  fopc->operation_id,
314  "A forwarded operation has timed out");
316  fopcq_tail,
317  fopc);
318  GNUNET_free (fopc);
319 }
320 
321 
331 static struct GNUNET_TESTING_SharedService *
332 parse_shared_services (char *ss_str,
334 {
336  struct GNUNET_TESTING_SharedService *slist;
337  char service[256];
338  char *arg;
339  unsigned int n;
340 
341 #define GROW_SS \
342  do { \
343  GNUNET_array_grow (slist, n, n + 1); \
344  GNUNET_memcpy (&slist[n - 1], &ss, \
345  sizeof(struct GNUNET_TESTING_SharedService)); \
346  } while (0)
347 
348  slist = NULL;
349  n = 0;
350  ss.cfg = cfg;
351  for (; NULL != (arg = strtok (ss_str, " ")); ss_str = NULL)
352  {
353  ss.service = NULL;
354  ss.share = 0;
355  if (2 != sscanf (arg, "%255[^:]:%u",
356  service,
357  &ss.share))
358  {
360  "Ignoring shared service spec: %s",
361  arg);
362  continue;
363  }
364  LOG_DEBUG ("Will be sharing %s service among %u peers\n",
365  service,
366  ss.share);
368  GROW_SS;
369  }
370  if (NULL != slist)
371  {
372  /* Add trailing NULL block */
373  (void) memset (&ss,
374  0,
375  sizeof(struct GNUNET_TESTING_SharedService));
376  GROW_SS;
377  }
378  return slist;
379 #undef GROW_SS
380 }
381 
382 
390 static int
391 check_init (void *cls,
392  const struct GNUNET_TESTBED_InitMessage *msg)
393 {
394  const char *controller_hostname;
395  uint16_t msize;
396 
397  msize = ntohs (msg->header.size) - sizeof(struct GNUNET_TESTBED_InitMessage);
398  controller_hostname = (const char *) &msg[1];
399  if ('\0' != controller_hostname[msize - 1])
400  {
401  GNUNET_break (0);
402  return GNUNET_SYSERR;
403  }
404  return GNUNET_OK;
405 }
406 
407 
414 static void
415 handle_init (void *cls,
416  const struct GNUNET_TESTBED_InitMessage *msg)
417 {
418  struct GNUNET_SERVICE_Client *client = cls;
419  struct GNUNET_TESTBED_Host *host;
420  const char *controller_hostname;
421  char *ss_str;
422  struct GNUNET_TESTING_SharedService *ss;
423  unsigned int cnt;
424 
425  if (NULL != GST_context)
426  {
427  LOG_DEBUG ("We are being connected to laterally\n");
429  return;
430  }
431  controller_hostname = (const char *) &msg[1];
432  ss_str = NULL;
433  ss = NULL;
434  if (GNUNET_OK ==
436  "TESTBED",
437  "SHARED_SERVICES",
438  &ss_str))
439  {
440  ss = parse_shared_services (ss_str,
441  GST_config);
442  GNUNET_free (ss_str);
443  ss_str = NULL;
444  }
445  GST_context = GNUNET_new (struct Context);
446  GST_context->client = client;
447  GST_context->host_id = ntohl (msg->host_id);
448  GST_context->master_ip = GNUNET_strdup (controller_hostname);
449  LOG_DEBUG ("Our IP: %s\n",
452  = GNUNET_TESTING_system_create ("testbed",
454  hostname,
455  ss);
456  if (NULL != ss)
457  {
458  for (cnt = 0; NULL != ss[cnt].service; cnt++)
459  {
460  ss_str = (char *) ss[cnt].service;
461  GNUNET_free (ss_str);
462  }
463  GNUNET_free (ss);
464  ss = NULL;
465  }
466  host =
469  NULL,
470  GST_config,
471  0);
472  host_list_add (host);
473  LOG_DEBUG ("Created master context with host ID: %u\n",
476 }
477 
478 
486 static int
487 check_add_host (void *cls,
488  const struct GNUNET_TESTBED_AddHostMessage *msg)
489 {
490  uint16_t username_length;
491  uint16_t hostname_length;
492  uint16_t msize;
493 
494  msize = ntohs (msg->header.size) - sizeof(struct
496  username_length = ntohs (msg->username_length);
497  hostname_length = ntohs (msg->hostname_length);
498  /* msg must contain hostname */
499  if ((msize <= username_length) ||
500  (0 == hostname_length))
501  {
502  GNUNET_break (0);
503  return GNUNET_SYSERR;
504  }
505  /* msg must contain configuration */
506  if (msize <= username_length + hostname_length)
507  {
508  GNUNET_break (0);
509  return GNUNET_SYSERR;
510  }
511  return GNUNET_OK;
512 }
513 
514 
521 static void
522 handle_add_host (void *cls,
523  const struct GNUNET_TESTBED_AddHostMessage *msg)
524 {
525  struct GNUNET_SERVICE_Client *client = cls;
526  struct GNUNET_TESTBED_Host *host;
528  struct GNUNET_CONFIGURATION_Handle *host_cfg;
529  char *username;
530  char *hostname;
531  char *emsg;
532  const void *ptr;
533  uint32_t host_id;
534  uint16_t username_length;
535  uint16_t hostname_length;
536  struct GNUNET_MQ_Envelope *env;
537 
538  username_length = ntohs (msg->username_length);
539  hostname_length = ntohs (msg->hostname_length);
540  username = NULL;
541  hostname = NULL;
542  ptr = &msg[1];
543  if (0 != username_length)
544  {
545  username = GNUNET_malloc (username_length + 1);
546  GNUNET_strlcpy (username, ptr, username_length + 1);
547  ptr += username_length;
548  }
549  hostname = GNUNET_malloc (hostname_length + 1);
550  GNUNET_strlcpy (hostname, ptr, hostname_length + 1);
551  if (NULL == (host_cfg = GNUNET_TESTBED_extract_config_ (&msg->header)))
552  {
553  GNUNET_free (username);
555  GNUNET_break_op (0);
557  return;
558  }
559  host_id = ntohl (msg->host_id);
560  LOG_DEBUG ("Received ADDHOST %u message\n", host_id);
561  LOG_DEBUG ("-------host id: %u\n", host_id);
562  LOG_DEBUG ("-------hostname: %s\n", hostname);
563  if (NULL != username)
564  LOG_DEBUG ("-------username: %s\n", username);
565  else
566  LOG_DEBUG ("-------username: <not given>\n");
567  LOG_DEBUG ("-------ssh port: %u\n", ntohs (msg->ssh_port));
568  host = GNUNET_TESTBED_host_create_with_id (host_id,
569  hostname,
570  username,
571  host_cfg,
572  ntohs (msg->ssh_port));
573  GNUNET_free (username);
575  GNUNET_CONFIGURATION_destroy (host_cfg);
576  if (NULL == host)
577  {
578  GNUNET_break_op (0);
580  return;
581  }
582  if (GNUNET_OK != host_list_add (host))
583  {
584  /* We are unable to add a host */
585  emsg = "A host exists with given host-id";
586  LOG_DEBUG ("%s: %u",
587  emsg,
588  host_id);
590  env = GNUNET_MQ_msg_extra (reply,
591  strlen (emsg) + 1,
593  GNUNET_memcpy (&reply[1],
594  emsg,
595  strlen (emsg) + 1);
596  }
597  else
598  {
599  LOG_DEBUG ("Added host %u at %u\n",
600  host_id,
602  env = GNUNET_MQ_msg (reply,
604  }
605  reply->host_id = htonl (host_id);
607  env);
609 }
610 
611 
618 static void
620  const struct
622 {
623  struct GNUNET_SERVICE_Client *client = cls;
624  struct Slave *slave;
625  struct GNUNET_TESTBED_SlaveConfiguration *reply;
626  const struct GNUNET_CONFIGURATION_Handle *cfg;
627  struct GNUNET_MQ_Envelope *env;
628  char *config;
629  char *xconfig;
630  size_t config_size;
631  size_t xconfig_size;
632  uint64_t op_id;
633  uint32_t slave_id;
634 
635  slave_id = ntohl (msg->slave_id);
636  op_id = GNUNET_ntohll (msg->operation_id);
637  if ((GST_slave_list_size <= slave_id) ||
638  (NULL == GST_slave_list[slave_id]))
639  {
640  /* FIXME: Add forwardings for this type of message here.. */
642  op_id,
643  "Slave not found");
645  return;
646  }
647  slave = GST_slave_list[slave_id];
649  GST_host_list[slave->host_id])));
651  &config_size);
652  /* FIXME: maybe we want to transmit the delta to the default here? */
653  xconfig_size = GNUNET_TESTBED_compress_config_ (config,
654  config_size,
655  &xconfig);
657  GNUNET_assert (xconfig_size + sizeof(struct
659  UINT16_MAX);
660  GNUNET_assert (xconfig_size <= UINT16_MAX);
661  env = GNUNET_MQ_msg_extra (reply,
662  xconfig_size,
664  reply->slave_id = msg->slave_id;
665  reply->operation_id = msg->operation_id;
666  reply->config_size = htons ((uint16_t) config_size);
667  GNUNET_memcpy (&reply[1],
668  xconfig,
669  xconfig_size);
670  GNUNET_free (xconfig);
672  env);
674 }
675 
676 
680 void
682 {
683  struct ForwardedOperationContext *fopc;
684 
685  while (NULL != (fopc = fopcq_head))
686  {
688  fopcq_tail,
689  fopc);
691  if (NULL != fopc->timeout_task)
693  switch (fopc->type)
694  {
695  case OP_PEER_CREATE:
696  GNUNET_free (fopc->cls);
697  break;
698 
699  case OP_SHUTDOWN_PEERS:
700  {
701  struct HandlerContext_ShutdownPeers *hc = fopc->cls;
702 
703  GNUNET_assert (0 < hc->nslaves);
704  hc->nslaves--;
705  if (0 == hc->nslaves)
706  GNUNET_free (hc);
707  }
708  break;
709 
710  case OP_PEER_START:
711  case OP_PEER_STOP:
712  case OP_PEER_DESTROY:
713  case OP_PEER_INFO:
714  case OP_OVERLAY_CONNECT:
715  case OP_LINK_CONTROLLERS:
716  case OP_GET_SLAVE_CONFIG:
717  case OP_MANAGE_SERVICE:
718  case OP_PEER_RECONFIGURE:
719  break;
720 
721  case OP_FORWARDED:
722  GNUNET_assert (0);
723  }
724  ;
725  GNUNET_free (fopc);
726  }
727 }
728 
729 
735 static void
736 shutdown_task (void *cls)
737 {
738  uint32_t id;
739 
740  LOG_DEBUG ("Shutting down testbed service\n");
741  /* cleanup any remaining forwarded operations */
742  GST_clear_fopcq ();
743  GST_free_lcf ();
744  GST_free_mctxq ();
745  GST_free_occq ();
746  GST_free_roccq ();
747  GST_free_nccq ();
749  GST_free_prcq ();
750  /* Clear peer list */
752  /* Clear route list */
754  /* Clear GST_slave_list */
756  /* Clear host list */
757  for (id = 0; id < GST_host_list_size; id++)
758  if (NULL != GST_host_list[id])
761  if (NULL != GST_context)
762  {
764  if (NULL != GST_context->system)
766  GNUNET_YES);
768  GST_context = NULL;
769  }
771  /* Free hello cache */
772  GST_cache_clear ();
775  GST_opq_openfds = NULL;
779 }
780 
781 
790 static void *
791 client_connect_cb (void *cls,
792  struct GNUNET_SERVICE_Client *client,
793  struct GNUNET_MQ_Handle *mq)
794 {
795  return client;
796 }
797 
798 
806 static void
808  struct GNUNET_SERVICE_Client *client,
809  void *app_ctx)
810 {
811  struct ForwardedOperationContext *fopc;
812  struct ForwardedOperationContext *fopcn;
813 
814  GNUNET_assert (client == app_ctx);
818  for (fopc = fopcq_head; NULL != fopc; fopc = fopcn)
819  {
820  fopcn = fopc->next;
821  if (fopc->client == client)
822  {
823  /* handle as if it were a timeout */
826  }
827  }
828  if (NULL == GST_context)
829  return;
830  if (client == GST_context->client)
831  {
833  "Master client disconnected\n");
834  GST_context->client = NULL;
835  /* should not be needed as we're terminated by failure to read
836  * from stdin, but if stdin fails for some reason, this shouldn't
837  * hurt for now --- might need to revise this later if we ever
838  * decide that master connections might be temporarily down
839  * for some reason */// GNUNET_SCHEDULER_shutdown ();
840  }
841 }
842 
843 
851 static void
853  const struct GNUNET_CONFIGURATION_Handle *cfg,
855 {
856  char *logfile;
857  unsigned long long num;
858 
859  LOG_DEBUG ("Starting testbed\n");
860  if (GNUNET_OK ==
861  GNUNET_CONFIGURATION_get_value_filename (cfg, "TESTBED", "LOG_FILE",
862  &logfile))
863  {
865  GNUNET_log_setup ("testbed",
866  "DEBUG",
867  logfile));
868  GNUNET_free (logfile);
869  }
872  "testbed",
873  "CACHE_SIZE",
874  &num));
875  GST_cache_init ((unsigned int) num);
876  GST_connection_pool_init ((unsigned int) num);
879  "testbed",
880  "MAX_OPEN_FDS",
881  &num));
884  (unsigned int) num);
887  "testbed",
888  "OPERATION_TIMEOUT",
889  &GST_timeout));
892  "testbed",
893  "HOSTNAME",
894  &hostname));
897  NULL);
898  LOG_DEBUG ("Testbed startup complete\n");
901 }
902 
903 
908  ("testbed",
910  &testbed_run,
913  NULL,
917  NULL),
921  NULL),
922  GNUNET_MQ_hd_fixed_size (slave_get_config,
925  NULL),
926  GNUNET_MQ_hd_fixed_size (link_controllers,
929  NULL),
930  GNUNET_MQ_hd_var_size (remote_overlay_connect,
933  NULL),
934  GNUNET_MQ_hd_fixed_size (overlay_connect,
937  NULL),
938  GNUNET_MQ_hd_var_size (peer_create,
941  NULL),
942  GNUNET_MQ_hd_fixed_size (peer_destroy,
945  NULL),
946  GNUNET_MQ_hd_fixed_size (peer_start,
949  NULL),
950  GNUNET_MQ_hd_fixed_size (peer_stop,
953  NULL),
954  GNUNET_MQ_hd_fixed_size (peer_get_config,
957  NULL),
958  GNUNET_MQ_hd_var_size (manage_peer_service,
961  NULL),
962  GNUNET_MQ_hd_fixed_size (shutdown_peers,
965  NULL),
966  GNUNET_MQ_hd_var_size (peer_reconfigure,
969  NULL),
970  GNUNET_MQ_hd_var_size (barrier_init,
973  NULL),
974  GNUNET_MQ_hd_var_size (barrier_cancel,
977  NULL),
978  GNUNET_MQ_hd_var_size (barrier_status,
981  NULL),
983 
984 
985 /* end of gnunet-service-testbed.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
#define LOG(kind,...)
Definition: abd_api.c:38
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static char * init
Set to the name of a service to start.
Definition: gnunet-arm.c:74
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
#define LOG_DEBUG(...)
Debug logging shorthand.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
static void add_host(const char *hostname, uint16_t rec_type, const void *data, size_t data_size)
Add information about a host from /etc/hosts to our cache.
void GST_forwarded_operation_reply_relay(void *cls, const struct GNUNET_MessageHeader *msg)
Callback to relay the reply msg of a forwarded operation back to the client.
struct OperationQueue * GST_opq_openfds
Operation queue for open file descriptors.
static void handle_add_host(void *cls, const struct GNUNET_TESTBED_AddHostMessage *msg)
Message handler for #GNUNET_MESSAGE_TYPE_TESTBED_ADDHOST messages.
static void register_next_host(struct Slave *slave)
Attempts to register the next host in the host registration queue.
#define GROW_SS
static struct GNUNET_TESTING_SharedService * parse_shared_services(char *ss_str, struct GNUNET_CONFIGURATION_Handle *cfg)
Parse service sharing specification line.
void GST_clear_fopcq()
Clears the forwarded operations queue.
static void hr_completion(void *cls, const char *emsg)
Callback which will be called after a host registration succeeded or failed.
struct ForwardedOperationContext * fopcq_head
DLL head for forwarded operation contexts.
struct GNUNET_TESTBED_Host ** GST_host_list
Array of hosts.
static int host_list_add(struct GNUNET_TESTBED_Host *host)
Function to add a host to the current list of known hosts.
struct Context * GST_context
The master context; generated with the first INIT message.
static void testbed_run(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_SERVICE_Handle *service)
Testbed setup.
struct GNUNET_TIME_Relative GST_timeout
Timeout for operations which may take some time.
static void shutdown_task(void *cls)
Task to clean up and shutdown nicely.
unsigned int GST_host_list_size
The size of the host list.
void GST_send_operation_fail_msg(struct GNUNET_SERVICE_Client *client, uint64_t operation_id, const char *emsg)
Send operation failure message to client.
static void handle_init(void *cls, const struct GNUNET_TESTBED_InitMessage *msg)
Message handler for GNUNET_MESSAGE_TYPE_TESTBED_INIT messages.
unsigned int GST_peer_list_size
The size of the peer list.
struct GNUNET_CONFIGURATION_Handle * GST_config
Our configuration.
void GST_queue_host_registration(struct Slave *slave, GNUNET_TESTBED_HostRegistrationCompletion cb, void *cb_cls, struct GNUNET_TESTBED_Host *host)
Adds a host registration's request to a slave's registration queue.
static int check_init(void *cls, const struct GNUNET_TESTBED_InitMessage *msg)
Check GNUNET_MESSAGE_TYPE_TESTBED_INIT messages.
static int check_add_host(void *cls, const struct GNUNET_TESTBED_AddHostMessage *msg)
Check #GNUNET_MESSAGE_TYPE_TESTBED_ADDHOST messages.
struct ForwardedOperationContext * fopcq_tail
DLL tail for forwarded operation contexts.
static void handle_slave_get_config(void *cls, const struct GNUNET_TESTBED_SlaveGetConfigurationMessage *msg)
Handler for #GNUNET_MESSAGE_TYPE_TESTBED_GETSLAVECONFIG messages.
static void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
Callback for client connect.
void GST_forwarded_operation_timeout(void *cls)
Task to free resources when forwarded operation has been timed out.
GNUNET_SERVICE_MAIN("testbed", GNUNET_SERVICE_OPTION_NONE, &testbed_run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(init, GNUNET_MESSAGE_TYPE_TESTBED_INIT, struct GNUNET_TESTBED_InitMessage, NULL), GNUNET_MQ_hd_var_size(add_host, GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST, struct GNUNET_TESTBED_AddHostMessage, NULL), GNUNET_MQ_hd_fixed_size(slave_get_config, GNUNET_MESSAGE_TYPE_TESTBED_GET_SLAVE_CONFIGURATION, struct GNUNET_TESTBED_SlaveGetConfigurationMessage, NULL), GNUNET_MQ_hd_fixed_size(link_controllers, GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS, struct GNUNET_TESTBED_ControllerLinkRequest, NULL), GNUNET_MQ_hd_var_size(remote_overlay_connect, GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT, struct GNUNET_TESTBED_RemoteOverlayConnectMessage, NULL), GNUNET_MQ_hd_fixed_size(overlay_connect, GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT, struct GNUNET_TESTBED_OverlayConnectMessage, NULL), GNUNET_MQ_hd_var_size(peer_create, GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER, struct GNUNET_TESTBED_PeerCreateMessage, NULL), GNUNET_MQ_hd_fixed_size(peer_destroy, GNUNET_MESSAGE_TYPE_TESTBED_DESTROY_PEER, struct GNUNET_TESTBED_PeerDestroyMessage, NULL), GNUNET_MQ_hd_fixed_size(peer_start, GNUNET_MESSAGE_TYPE_TESTBED_START_PEER, struct GNUNET_TESTBED_PeerStartMessage, NULL), GNUNET_MQ_hd_fixed_size(peer_stop, GNUNET_MESSAGE_TYPE_TESTBED_STOP_PEER, struct GNUNET_TESTBED_PeerStopMessage, NULL), GNUNET_MQ_hd_fixed_size(peer_get_config, GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_INFORMATION, struct GNUNET_TESTBED_PeerGetConfigurationMessage, NULL), GNUNET_MQ_hd_var_size(manage_peer_service, GNUNET_MESSAGE_TYPE_TESTBED_MANAGE_PEER_SERVICE, struct GNUNET_TESTBED_ManagePeerServiceMessage, NULL), GNUNET_MQ_hd_fixed_size(shutdown_peers, GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS, struct GNUNET_TESTBED_ShutdownPeersMessage, NULL), GNUNET_MQ_hd_var_size(peer_reconfigure, GNUNET_MESSAGE_TYPE_TESTBED_RECONFIGURE_PEER, struct GNUNET_TESTBED_PeerReconfigureMessage, NULL), GNUNET_MQ_hd_var_size(barrier_init, GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT, struct GNUNET_TESTBED_BarrierInit, NULL), GNUNET_MQ_hd_var_size(barrier_cancel, GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL, struct GNUNET_TESTBED_BarrierCancel, NULL), GNUNET_MQ_hd_var_size(barrier_status, GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS, struct GNUNET_TESTBED_BarrierStatusMsg, NULL), GNUNET_MQ_handler_end())
Define "main" method using service macro.
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
Callback for client disconnect.
void GST_send_operation_success_msg(struct GNUNET_SERVICE_Client *client, uint64_t operation_id)
Function to send generic operation success message to given client.
static char * hostname
Our hostname; we give this to all the peers we start.
data structures shared amongst components of TESTBED service
void GST_route_list_clear(void)
Cleans up the route list.
void GST_free_mctxq(void)
Frees the ManageServiceContext queue.
void GST_stats_init(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize logging CPU and IO statisticfs.
#define GST_array_grow_large_enough(ptr, size, accommodate_size)
Similar to GNUNET_array_grow(); however instead of calling GNUNET_array_grow() several times we call ...
void GST_notify_client_disconnect_peers(struct GNUNET_SERVICE_Client *client)
Notify peers subsystem that client disconnected.
void GST_destroy_peers(void)
Stops and destroys all peers.
void GST_cache_clear(void)
Clear cache.
void GST_stats_destroy(void)
Shutdown the status calls module.
void GST_free_lcf(void)
Cleans up the queue used for forwarding link controllers requests.
void GST_free_roccq(void)
Clears all pending remote overlay connect contexts in queue.
void GST_notify_client_disconnect_oc(struct GNUNET_SERVICE_Client *client)
Notify OC subsystem that client disconnected.
void GST_cache_init(unsigned int size)
Initializes the cache.
void GST_free_prcq(void)
Cleans up the Peer reconfigure context list.
void GST_free_occq(void)
Clears all pending overlay connect contexts in queue.
void GST_barriers_init(struct GNUNET_CONFIGURATION_Handle *cfg)
Function to initialise barriers component.
void GST_barriers_destroy()
Function to stop the barrier service.
Interface for the barrier initialisation handler routine.
void GST_connection_pool_destroy()
Cleanup the connection pool.
void GST_connection_pool_init(unsigned int size)
Initialise the connection pool.
Interface for connection pooling subroutines.
static const struct GNUNET_CONFIGURATION_Handle * config
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:53
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:36
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_NO
Definition: gnunet_common.h:94
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
char * GNUNET_CONFIGURATION_serialize(const struct GNUNET_CONFIGURATION_Handle *cfg, size_t *size)
Serializes the given configuration.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_time(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, struct GNUNET_TIME_Relative *time)
Get a configuration value that should be a relative time.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_dup(const struct GNUNET_CONFIGURATION_Handle *cfg)
Duplicate an existing configuration object.
#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.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
int GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
#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_WARNING
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
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:355
#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:52
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#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:666
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_TESTBED_INIT
Initial message from a client to a testing control service.
#define GNUNET_MESSAGE_TYPE_TESTBED_START_PEER
Message to start a peer at a host.
#define GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT
Message to initialise a barrier.
#define GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL
Message to cancel a barrier.
#define GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST
Message to add host.
#define GNUNET_MESSAGE_TYPE_TESTBED_MANAGE_PEER_SERVICE
Message to start/stop a service of a peer.
#define GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT
Message to connect peers in a overlay.
#define GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_INFORMATION
Message to get a peer's information.
#define GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT
Message to request a controller to make one of its peer to connect to another peer using the containe...
#define GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS
Message for signalling status of a barrier.
#define GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST_SUCCESS
Message to signal that a add host succeeded.
#define GNUNET_MESSAGE_TYPE_TESTBED_SLAVE_CONFIGURATION
Message which contains the configuration of slave controller.
#define GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS
Message to link delegated controller to slave controller.
#define GNUNET_MESSAGE_TYPE_TESTBED_GENERIC_OPERATION_SUCCESS
Message to signal a generic operation has been successful.
#define GNUNET_MESSAGE_TYPE_TESTBED_GET_SLAVE_CONFIGURATION
Message to request configuration of a slave controller.
#define GNUNET_MESSAGE_TYPE_TESTBED_RECONFIGURE_PEER
Message to reconfigure a peer.
#define GNUNET_MESSAGE_TYPE_TESTBED_STOP_PEER
Message to stop a peer at a host.
#define GNUNET_MESSAGE_TYPE_TESTBED_DESTROY_PEER
Message to destroy a peer.
#define GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER
Message to create a peer at a host.
#define GNUNET_MESSAGE_TYPE_TESTBED_OPERATION_FAIL_EVENT
Message for operation events.
#define GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS
A controller receiving this message floods it to its directly-connected sub-controllers and then stop...
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1331
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2325
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2438
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2244
@ GNUNET_SERVICE_OPTION_NONE
Use defaults.
size_t GNUNET_strlcpy(char *dst, const char *src, size_t n)
Like strlcpy but portable.
Definition: strings.c:162
struct GNUNET_TESTBED_Host * GNUNET_TESTBED_host_create_with_id(uint32_t id, const char *hostname, const char *username, const struct GNUNET_CONFIGURATION_Handle *cfg, uint16_t port)
Create a host to run peers and controllers on.
void(* GNUNET_TESTBED_HostRegistrationCompletion)(void *cls, const char *emsg)
Callback which will be called to after a host registration succeeded or failed.
void GNUNET_TESTBED_host_destroy(struct GNUNET_TESTBED_Host *host)
Destroy a host handle.
struct GNUNET_TESTBED_HostRegistrationHandle * GNUNET_TESTBED_register_host(struct GNUNET_TESTBED_Controller *controller, struct GNUNET_TESTBED_Host *host, GNUNET_TESTBED_HostRegistrationCompletion cc, void *cc_cls)
Register a host with the controller.
@ GNUNET_TESTBED_ET_OPERATION_FINISHED
A requested testbed operation has been completed.
struct GNUNET_TESTING_System * GNUNET_TESTING_system_create(const char *testdir, const char *trusted_ip, const char *hostname, const struct GNUNET_TESTING_SharedService *shared_services)
Create a system handle.
Definition: testing.c:449
void GNUNET_TESTING_system_destroy(struct GNUNET_TESTING_System *system, int remove_paths)
Free system resources.
Definition: testing.c:529
Context to hold data of peer.
char * master_ip
The network address of the master controller.
struct GNUNET_SERVICE_Client * client
The client handle associated with this context.
uint32_t host_id
Our host id according to this context.
struct GNUNET_TESTING_System * system
The TESTING system handle for starting peers locally.
Context information for operations forwarded to subcontrollers.
struct GNUNET_SCHEDULER_Task * timeout_task
Task ID for the timeout task.
enum OperationType type
The type of the operation which is forwarded.
struct OperationContext * opc
The generated operation context.
struct GNUNET_SERVICE_Client * client
The client to which we have to reply.
struct ForwardedOperationContext * next
The next pointer for DLL.
uint64_t operation_id
The id of the operation that has been forwarded.
Handle to a message queue.
Definition: mq.c:86
Header for all communications.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Handle to a client that is connected to a service.
Definition: service.c:251
Handle to a service.
Definition: service.c:117
Notify the service about a host that we intend to use.
Definition: testbed.h:65
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
Client notifies controller that it should delegate requests for a particular client to a particular s...
Definition: testbed.h:137
Event notification from a controller to a client for a generic operational success where the operatio...
Definition: testbed.h:558
uint64_t operation_id
Operation ID of the operation that created this event.
Definition: testbed.h:573
Confirmation from the service that adding a host worked (or failed).
Definition: testbed.h:115
uint32_t host_id
Unique ID for the host (in NBO).
Definition: testbed.h:124
Opaque handle to a host running experiments managed by the testing framework.
Initial message from a client to a testing control service.
Definition: testbed.h:37
Message to start/stop services of a peer.
Definition: testbed.h:706
Event notification from a controller to a client.
Definition: testbed.h:509
uint64_t operation_id
Operation ID of the operation that created this event.
Definition: testbed.h:524
Message sent from client to testing service to connect two peers.
Definition: testbed.h:376
Message sent from client to testing service to create (configure, but not start) a peer.
Definition: testbed.h:205
Message sent from client to testing service to destroy a (stopped) peer.
Definition: testbed.h:318
Message sent from client to testing service to obtain the configuration of a peer.
Definition: testbed.h:582
Message sent from client to testing service to reconfigure a (stopped) a peer.
Definition: testbed.h:241
Message sent from client to testing service to start a peer.
Definition: testbed.h:272
Message sent from client to testing service to stop a peer.
Definition: testbed.h:295
Message sent from host controller of a peer(A) to the host controller of another peer(B) to request B...
Definition: testbed.h:409
Shutdown peers message.
Definition: testbed.h:689
Reply to GNUNET_MESSAGE_TYPE_TESTBED_GET_SLAVE_CONFIGURATION message.
Definition: testbed.h:660
uint64_t operation_id
Operation ID.
Definition: testbed.h:674
uint16_t config_size
The size of the configuration when uncompressed.
Definition: testbed.h:679
uint32_t slave_id
The id of the host where the slave is running.
Definition: testbed.h:669
Message to request configuration of a slave controller.
Definition: testbed.h:638
Specification of a service that is to be shared among peers.
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration template for the service.
unsigned int share
The number of peers which share an instance of the service.
const char * service
The name of the service.
Time for relative time used by GNUnet, in microseconds.
Context data for GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS handler.
unsigned int nslaves
The number of slave we expect to hear from since we forwarded the GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOW...
A DLL of host registrations to be made.
struct GNUNET_TESTBED_Host * host
The host that has to be registered.
GNUNET_TESTBED_HostRegistrationCompletion cb
The callback to call after this registration's status is available.
void * cb_cls
The closure for the above callback.
Queue of operations where we can only support a certain number of concurrent operations of a particul...
Structure representing a connected(directly-linked) controller.
uint32_t host_id
The id of the host this controller is running on.
struct HostRegistration * hr_dll_tail
Tail of the host registration DLL.
struct GNUNET_TESTBED_Controller * controller
The controller handle.
struct HostRegistration * hr_dll_head
Head of the host registration DLL.
struct GNUNET_TESTBED_HostRegistrationHandle * rhandle
The current host registration handle.
void GNUNET_TESTBED_forward_operation_msg_cancel_(struct OperationContext *opc)
Function to cancel an operation created by simply forwarding an operation message.
Definition: testbed_api.c:1407
struct GNUNET_CONFIGURATION_Handle * GNUNET_TESTBED_extract_config_(const struct GNUNET_MessageHeader *msg)
Generates configuration by uncompressing configuration in given message.
Definition: testbed_api.c:2067
size_t GNUNET_TESTBED_compress_config_(const char *config, size_t size, char **xconfig)
Compresses given configuration using zlib compress.
Definition: testbed_api.c:1758
@ OP_GET_SLAVE_CONFIG
Get slave config operation.
Definition: testbed_api.h:94
@ OP_PEER_RECONFIGURE
Reconfigure a peer.
Definition: testbed_api.h:74
@ OP_FORWARDED
Forwarded operation.
Definition: testbed_api.h:84
@ OP_PEER_START
Peer start operation.
Definition: testbed_api.h:54
@ OP_PEER_INFO
Get peer information operation.
Definition: testbed_api.h:69
@ OP_SHUTDOWN_PEERS
Stop and destroy all peers.
Definition: testbed_api.h:99
@ OP_MANAGE_SERVICE
Start/stop service at a peer.
Definition: testbed_api.h:104
@ OP_PEER_DESTROY
Peer destroy operation.
Definition: testbed_api.h:64
@ OP_OVERLAY_CONNECT
Overlay connection operation.
Definition: testbed_api.h:79
@ OP_LINK_CONTROLLERS
Link controllers operation.
Definition: testbed_api.h:89
@ OP_PEER_STOP
Peer stop operation.
Definition: testbed_api.h:59
@ OP_PEER_CREATE
Peer create operation.
Definition: testbed_api.h:49
const struct GNUNET_CONFIGURATION_Handle * GNUNET_TESTBED_host_get_cfg_(const struct GNUNET_TESTBED_Host *host)
Obtain the host's configuration template.
uint32_t GNUNET_TESTBED_host_get_id_(const struct GNUNET_TESTBED_Host *host)
Obtain the host's unique global ID.
struct OperationQueue * GNUNET_TESTBED_operation_queue_create_(enum OperationQueueType type, unsigned int max_active)
Create an operation queue.
void GNUNET_TESTBED_operation_queue_destroy_(struct OperationQueue *queue)
Destroys an operation queue.
@ OPERATION_QUEUE_TYPE_FIXED
Operation queue which permits a fixed maximum number of operations to be active at any time.