GNUnet  0.19.3
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 "platform.h"
28 #include "gnunet-service-testbed.h"
31 
32 /***********/
33 /* Globals */
34 /***********/
35 
40 
45 
50 
55 
60 
65 
70 
74 unsigned int GST_host_list_size;
75 
79 unsigned int GST_peer_list_size;
80 
81 
82 /***********************************/
83 /* Local definitions and variables */
84 /***********************************/
85 
89 static char *hostname;
90 
91 
99 static int
101 {
102  uint32_t host_id;
103 
104  host_id = GNUNET_TESTBED_host_get_id_ (host);
105  if (GST_host_list_size <= host_id)
107  if (NULL != GST_host_list[host_id])
108  {
109  LOG_DEBUG ("A host with id: %u already exists\n", host_id);
110  return GNUNET_SYSERR;
111  }
112  GST_host_list[host_id] = host;
113  return GNUNET_OK;
114 }
115 
116 
124 void
126  uint64_t operation_id,
127  const char *emsg)
128 {
129  struct GNUNET_MQ_Envelope *env;
131  uint16_t emsg_len;
132 
133  emsg_len = (NULL == emsg) ? 0 : strlen (emsg) + 1;
135  emsg_len,
137  msg->event_type = htonl (GNUNET_TESTBED_ET_OPERATION_FINISHED);
138  msg->operation_id = GNUNET_htonll (operation_id);
139  GNUNET_memcpy (&msg[1],
140  emsg,
141  emsg_len);
143  env);
144 }
145 
146 
153 void
155  uint64_t operation_id)
156 {
157  struct GNUNET_MQ_Envelope *env;
159 
160  env = GNUNET_MQ_msg (msg,
162  msg->operation_id = GNUNET_htonll (operation_id);
163  msg->event_type = htonl (GNUNET_TESTBED_ET_OPERATION_FINISHED);
165  env);
166 }
167 
168 
175 static void
176 hr_completion (void *cls,
177  const char *emsg);
178 
179 
186 static void
187 register_next_host (struct Slave *slave)
188 {
189  struct HostRegistration *hr;
190 
191  hr = slave->hr_dll_head;
192  GNUNET_assert (NULL != hr);
193  GNUNET_assert (NULL == slave->rhandle);
194  LOG (GNUNET_ERROR_TYPE_DEBUG, "Registering host %u at %u\n",
197  slave->rhandle
199  hr->host,
201  slave);
202 }
203 
204 
211 static void
212 hr_completion (void *cls,
213  const char *emsg)
214 {
215  struct Slave *slave = cls;
216  struct HostRegistration *hr;
217 
218  slave->rhandle = NULL;
219  hr = slave->hr_dll_head;
220  GNUNET_assert (NULL != hr);
222  "Registering host %u at %u successful\n",
226  slave->hr_dll_tail,
227  hr);
228  if (NULL != hr->cb)
229  hr->cb (hr->cb_cls,
230  emsg);
231  GNUNET_free (hr);
232  if (NULL != slave->hr_dll_head)
233  register_next_host (slave);
234 }
235 
236 
246 void
249  void *cb_cls,
250  struct GNUNET_TESTBED_Host *host)
251 {
252  struct HostRegistration *hr;
253  int call_register;
254 
256  "Queueing host registration for host %u at %u\n",
259  hr = GNUNET_new (struct HostRegistration);
260  hr->cb = cb;
261  hr->cb_cls = cb_cls;
262  hr->host = host;
263  call_register = (NULL == slave->hr_dll_head) ? GNUNET_YES : GNUNET_NO;
265  slave->hr_dll_tail,
266  hr);
267  if (GNUNET_YES == call_register)
268  register_next_host (slave);
269 }
270 
271 
278 void
280  const struct GNUNET_MessageHeader *msg)
281 {
282  struct ForwardedOperationContext *fopc = cls;
283  struct GNUNET_MQ_Envelope *env;
284 
285  LOG_DEBUG ("Relaying message with type: %u, size: %u\n",
286  ntohs (msg->type),
287  ntohs (msg->size));
290  env);
293  fopcq_tail,
294  fopc);
295  GNUNET_free (fopc);
296 }
297 
298 
299 void
301 {
302  struct ForwardedOperationContext *fopc = cls;
303 
304  fopc->timeout_task = NULL;
307  "A forwarded operation has timed out\n");
309  fopc->operation_id,
310  "A forwarded operation has timed out");
312  fopcq_tail,
313  fopc);
314  GNUNET_free (fopc);
315 }
316 
317 
327 static struct GNUNET_TESTING_SharedService *
328 parse_shared_services (char *ss_str,
330 {
332  struct GNUNET_TESTING_SharedService *slist;
333  char service[256];
334  char *arg;
335  unsigned int n;
336 
337 #define GROW_SS \
338  do { \
339  GNUNET_array_grow (slist, n, n + 1); \
340  GNUNET_memcpy (&slist[n - 1], &ss, \
341  sizeof(struct GNUNET_TESTING_SharedService)); \
342  } while (0)
343 
344  slist = NULL;
345  n = 0;
346  ss.cfg = cfg;
347  for (; NULL != (arg = strtok (ss_str, " ")); ss_str = NULL)
348  {
349  ss.service = NULL;
350  ss.share = 0;
351  if (2 != sscanf (arg, "%255[^:]:%u",
352  service,
353  &ss.share))
354  {
356  "Ignoring shared service spec: %s",
357  arg);
358  continue;
359  }
360  LOG_DEBUG ("Will be sharing %s service among %u peers\n",
361  service,
362  ss.share);
364  GROW_SS;
365  }
366  if (NULL != slist)
367  {
368  /* Add trailing NULL block */
369  (void) memset (&ss,
370  0,
371  sizeof(struct GNUNET_TESTING_SharedService));
372  GROW_SS;
373  }
374  return slist;
375 #undef GROW_SS
376 }
377 
378 
386 static int
387 check_init (void *cls,
388  const struct GNUNET_TESTBED_InitMessage *msg)
389 {
390  const char *controller_hostname;
391  uint16_t msize;
392 
393  msize = ntohs (msg->header.size) - sizeof(struct GNUNET_TESTBED_InitMessage);
394  controller_hostname = (const char *) &msg[1];
395  if ('\0' != controller_hostname[msize - 1])
396  {
397  GNUNET_break (0);
398  return GNUNET_SYSERR;
399  }
400  return GNUNET_OK;
401 }
402 
403 
410 static void
411 handle_init (void *cls,
412  const struct GNUNET_TESTBED_InitMessage *msg)
413 {
414  struct GNUNET_SERVICE_Client *client = cls;
415  struct GNUNET_TESTBED_Host *host;
416  const char *controller_hostname;
417  char *ss_str;
418  struct GNUNET_TESTING_SharedService *ss;
419  unsigned int cnt;
420 
421  if (NULL != GST_context)
422  {
423  LOG_DEBUG ("We are being connected to laterally\n");
425  return;
426  }
427  controller_hostname = (const char *) &msg[1];
428  ss_str = NULL;
429  ss = NULL;
430  if (GNUNET_OK ==
432  "TESTBED",
433  "SHARED_SERVICES",
434  &ss_str))
435  {
436  ss = parse_shared_services (ss_str,
437  GST_config);
438  GNUNET_free (ss_str);
439  ss_str = NULL;
440  }
441  GST_context = GNUNET_new (struct Context);
442  GST_context->client = client;
443  GST_context->host_id = ntohl (msg->host_id);
444  GST_context->master_ip = GNUNET_strdup (controller_hostname);
445  LOG_DEBUG ("Our IP: %s\n",
448  = GNUNET_TESTING_system_create ("testbed",
450  hostname,
451  ss);
452  if (NULL != ss)
453  {
454  for (cnt = 0; NULL != ss[cnt].service; cnt++)
455  {
456  ss_str = (char *) ss[cnt].service;
457  GNUNET_free (ss_str);
458  }
459  GNUNET_free (ss);
460  ss = NULL;
461  }
462  host =
465  NULL,
466  GST_config,
467  0);
468  host_list_add (host);
469  LOG_DEBUG ("Created master context with host ID: %u\n",
472 }
473 
474 
482 static int
483 check_add_host (void *cls,
484  const struct GNUNET_TESTBED_AddHostMessage *msg)
485 {
486  uint16_t username_length;
487  uint16_t hostname_length;
488  uint16_t msize;
489 
490  msize = ntohs (msg->header.size) - sizeof(struct
492  username_length = ntohs (msg->username_length);
493  hostname_length = ntohs (msg->hostname_length);
494  /* msg must contain hostname */
495  if ((msize <= username_length) ||
496  (0 == hostname_length))
497  {
498  GNUNET_break (0);
499  return GNUNET_SYSERR;
500  }
501  /* msg must contain configuration */
502  if (msize <= username_length + hostname_length)
503  {
504  GNUNET_break (0);
505  return GNUNET_SYSERR;
506  }
507  return GNUNET_OK;
508 }
509 
510 
517 static void
518 handle_add_host (void *cls,
519  const struct GNUNET_TESTBED_AddHostMessage *msg)
520 {
521  struct GNUNET_SERVICE_Client *client = cls;
522  struct GNUNET_TESTBED_Host *host;
524  struct GNUNET_CONFIGURATION_Handle *host_cfg;
525  char *username;
526  char *hostname;
527  char *emsg;
528  const void *ptr;
529  uint32_t host_id;
530  uint16_t username_length;
531  uint16_t hostname_length;
532  struct GNUNET_MQ_Envelope *env;
533 
534  username_length = ntohs (msg->username_length);
535  hostname_length = ntohs (msg->hostname_length);
536  username = NULL;
537  hostname = NULL;
538  ptr = &msg[1];
539  if (0 != username_length)
540  {
541  username = GNUNET_malloc (username_length + 1);
542  GNUNET_strlcpy (username, ptr, username_length + 1);
543  ptr += username_length;
544  }
545  hostname = GNUNET_malloc (hostname_length + 1);
546  GNUNET_strlcpy (hostname, ptr, hostname_length + 1);
547  if (NULL == (host_cfg = GNUNET_TESTBED_extract_config_ (&msg->header)))
548  {
549  GNUNET_free (username);
551  GNUNET_break_op (0);
553  return;
554  }
555  host_id = ntohl (msg->host_id);
556  LOG_DEBUG ("Received ADDHOST %u message\n", host_id);
557  LOG_DEBUG ("-------host id: %u\n", host_id);
558  LOG_DEBUG ("-------hostname: %s\n", hostname);
559  if (NULL != username)
560  LOG_DEBUG ("-------username: %s\n", username);
561  else
562  LOG_DEBUG ("-------username: <not given>\n");
563  LOG_DEBUG ("-------ssh port: %u\n", ntohs (msg->ssh_port));
564  host = GNUNET_TESTBED_host_create_with_id (host_id,
565  hostname,
566  username,
567  host_cfg,
568  ntohs (msg->ssh_port));
569  GNUNET_free (username);
571  GNUNET_CONFIGURATION_destroy (host_cfg);
572  if (NULL == host)
573  {
574  GNUNET_break_op (0);
576  return;
577  }
578  if (GNUNET_OK != host_list_add (host))
579  {
580  /* We are unable to add a host */
581  emsg = "A host exists with given host-id";
582  LOG_DEBUG ("%s: %u",
583  emsg,
584  host_id);
586  env = GNUNET_MQ_msg_extra (reply,
587  strlen (emsg) + 1,
589  GNUNET_memcpy (&reply[1],
590  emsg,
591  strlen (emsg) + 1);
592  }
593  else
594  {
595  LOG_DEBUG ("Added host %u at %u\n",
596  host_id,
598  env = GNUNET_MQ_msg (reply,
600  }
601  reply->host_id = htonl (host_id);
603  env);
605 }
606 
607 
614 static void
616  const struct
618 {
619  struct GNUNET_SERVICE_Client *client = cls;
620  struct Slave *slave;
621  struct GNUNET_TESTBED_SlaveConfiguration *reply;
622  const struct GNUNET_CONFIGURATION_Handle *cfg;
623  struct GNUNET_MQ_Envelope *env;
624  char *config;
625  char *xconfig;
626  size_t config_size;
627  size_t xconfig_size;
628  uint64_t op_id;
629  uint32_t slave_id;
630 
631  slave_id = ntohl (msg->slave_id);
632  op_id = GNUNET_ntohll (msg->operation_id);
633  if ((GST_slave_list_size <= slave_id) ||
634  (NULL == GST_slave_list[slave_id]))
635  {
636  /* FIXME: Add forwardings for this type of message here.. */
638  op_id,
639  "Slave not found");
641  return;
642  }
643  slave = GST_slave_list[slave_id];
645  GST_host_list[slave->host_id])));
647  &config_size);
648  /* FIXME: maybe we want to transmit the delta to the default here? */
649  xconfig_size = GNUNET_TESTBED_compress_config_ (config,
650  config_size,
651  &xconfig);
653  GNUNET_assert (xconfig_size + sizeof(struct
655  UINT16_MAX);
656  GNUNET_assert (xconfig_size <= UINT16_MAX);
657  env = GNUNET_MQ_msg_extra (reply,
658  xconfig_size,
660  reply->slave_id = msg->slave_id;
661  reply->operation_id = msg->operation_id;
662  reply->config_size = htons ((uint16_t) config_size);
663  GNUNET_memcpy (&reply[1],
664  xconfig,
665  xconfig_size);
666  GNUNET_free (xconfig);
668  env);
670 }
671 
672 
676 void
678 {
679  struct ForwardedOperationContext *fopc;
680 
681  while (NULL != (fopc = fopcq_head))
682  {
684  fopcq_tail,
685  fopc);
687  if (NULL != fopc->timeout_task)
689  switch (fopc->type)
690  {
691  case OP_PEER_CREATE:
692  GNUNET_free (fopc->cls);
693  break;
694 
695  case OP_SHUTDOWN_PEERS:
696  {
697  struct HandlerContext_ShutdownPeers *hc = fopc->cls;
698 
699  GNUNET_assert (0 < hc->nslaves);
700  hc->nslaves--;
701  if (0 == hc->nslaves)
702  GNUNET_free (hc);
703  }
704  break;
705 
706  case OP_PEER_START:
707  case OP_PEER_STOP:
708  case OP_PEER_DESTROY:
709  case OP_PEER_INFO:
710  case OP_OVERLAY_CONNECT:
711  case OP_LINK_CONTROLLERS:
712  case OP_GET_SLAVE_CONFIG:
713  case OP_MANAGE_SERVICE:
714  case OP_PEER_RECONFIGURE:
715  break;
716 
717  case OP_FORWARDED:
718  GNUNET_assert (0);
719  }
720  ;
721  GNUNET_free (fopc);
722  }
723 }
724 
725 
731 static void
732 shutdown_task (void *cls)
733 {
734  uint32_t id;
735 
736  LOG_DEBUG ("Shutting down testbed service\n");
737  /* cleanup any remaining forwarded operations */
738  GST_clear_fopcq ();
739  GST_free_lcf ();
740  GST_free_mctxq ();
741  GST_free_occq ();
742  GST_free_roccq ();
743  GST_free_nccq ();
745  GST_free_prcq ();
746  /* Clear peer list */
748  /* Clear route list */
750  /* Clear GST_slave_list */
752  /* Clear host list */
753  for (id = 0; id < GST_host_list_size; id++)
754  if (NULL != GST_host_list[id])
757  if (NULL != GST_context)
758  {
760  if (NULL != GST_context->system)
762  GNUNET_YES);
764  GST_context = NULL;
765  }
767  /* Free hello cache */
768  GST_cache_clear ();
771  GST_opq_openfds = NULL;
775 }
776 
777 
786 static void *
787 client_connect_cb (void *cls,
788  struct GNUNET_SERVICE_Client *client,
789  struct GNUNET_MQ_Handle *mq)
790 {
791  return client;
792 }
793 
794 
802 static void
804  struct GNUNET_SERVICE_Client *client,
805  void *app_ctx)
806 {
807  struct ForwardedOperationContext *fopc;
808  struct ForwardedOperationContext *fopcn;
809 
810  GNUNET_assert (client == app_ctx);
814  for (fopc = fopcq_head; NULL != fopc; fopc = fopcn)
815  {
816  fopcn = fopc->next;
817  if (fopc->client == client)
818  {
819  /* handle as if it were a timeout */
822  }
823  }
824  if (NULL == GST_context)
825  return;
826  if (client == GST_context->client)
827  {
829  "Master client disconnected\n");
830  GST_context->client = NULL;
831  /* should not be needed as we're terminated by failure to read
832  * from stdin, but if stdin fails for some reason, this shouldn't
833  * hurt for now --- might need to revise this later if we ever
834  * decide that master connections might be temporarily down
835  * for some reason */// GNUNET_SCHEDULER_shutdown ();
836  }
837 }
838 
839 
847 static void
849  const struct GNUNET_CONFIGURATION_Handle *cfg,
851 {
852  char *logfile;
853  unsigned long long num;
854 
855  LOG_DEBUG ("Starting testbed\n");
856  if (GNUNET_OK ==
857  GNUNET_CONFIGURATION_get_value_filename (cfg, "TESTBED", "LOG_FILE",
858  &logfile))
859  {
861  GNUNET_log_setup ("testbed",
862  "DEBUG",
863  logfile));
864  GNUNET_free (logfile);
865  }
868  "testbed",
869  "CACHE_SIZE",
870  &num));
871  GST_cache_init ((unsigned int) num);
872  GST_connection_pool_init ((unsigned int) num);
875  "testbed",
876  "MAX_OPEN_FDS",
877  &num));
880  (unsigned int) num);
883  "testbed",
884  "OPERATION_TIMEOUT",
885  &GST_timeout));
888  "testbed",
889  "HOSTNAME",
890  &hostname));
893  NULL);
894  LOG_DEBUG ("Testbed startup complete\n");
897 }
898 
899 
904  ("testbed",
906  &testbed_run,
909  NULL,
913  NULL),
917  NULL),
918  GNUNET_MQ_hd_fixed_size (slave_get_config,
921  NULL),
922  GNUNET_MQ_hd_fixed_size (link_controllers,
925  NULL),
926  GNUNET_MQ_hd_var_size (remote_overlay_connect,
929  NULL),
930  GNUNET_MQ_hd_fixed_size (overlay_connect,
933  NULL),
934  GNUNET_MQ_hd_var_size (peer_create,
937  NULL),
938  GNUNET_MQ_hd_fixed_size (peer_destroy,
941  NULL),
942  GNUNET_MQ_hd_fixed_size (peer_start,
945  NULL),
946  GNUNET_MQ_hd_fixed_size (peer_stop,
949  NULL),
950  GNUNET_MQ_hd_fixed_size (peer_get_config,
953  NULL),
954  GNUNET_MQ_hd_var_size (manage_peer_service,
957  NULL),
958  GNUNET_MQ_hd_fixed_size (shutdown_peers,
961  NULL),
962  GNUNET_MQ_hd_var_size (peer_reconfigure,
965  NULL),
966  GNUNET_MQ_hd_var_size (barrier_init,
969  NULL),
970  GNUNET_MQ_hd_var_size (barrier_cancel,
973  NULL),
974  GNUNET_MQ_hd_var_size (barrier_status,
977  NULL),
979 
980 
981 /* 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
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.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:37
#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.
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: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_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:77
#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_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:1334
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
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
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2249
@ 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:138
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:477
void GNUNET_TESTING_system_destroy(struct GNUNET_TESTING_System *system, int remove_paths)
Free system resources.
Definition: testing.c:557
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:87
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:252
Handle to a service.
Definition: service.c:118
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:2043
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 a 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.