2 This file is part of GNUnet
3 (C) 2008--2013 Christian Grothoff (and other contributing authors)
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 3, or (at your
8 option) any later version.
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 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.
22 * @file testbed/testbed_api_hosts.c
23 * @brief API for manipulating 'hosts' controlled by the GNUnet testing service;
24 * allows parsing hosts files, starting, stopping and communicating (via
25 * SSH/stdin/stdout) with the remote (or local) processes
26 * @author Christian Grothoff
29 #include "gnunet_util_lib.h"
30 #include "gnunet_testbed_service.h"
31 #include "gnunet_core_service.h"
32 #include "gnunet_transport_service.h"
34 #include "testbed_api.h"
35 #include "testbed_api_hosts.h"
36 #include "testbed_helper.h"
37 #include "testbed_api_operations.h"
38 #include "testbed_api_sd.h"
43 * Generic logging shorthand
45 #define LOG(kind, ...) \
46 GNUNET_log_from (kind, "testbed-api-hosts", __VA_ARGS__);
49 * Debug logging shorthand
51 #define LOG_DEBUG(...) \
52 LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__);
55 * Prints API violation message
57 #define API_VIOLATION(cond,errstr) \
61 LOG (GNUNET_ERROR_TYPE_ERROR, "API violation detected: %s\n", errstr); \
66 * Log an error message at log-level 'level' that indicates a failure of the
67 * command 'cmd' with the message given by gai_strerror(rc).
69 #define LOG_GAI(level, cmd, rc) do { LOG(level, _("`%s' failed at %s:%d with error: %s\n"), cmd, __FILE__, __LINE__, gai_strerror(rc)); } while(0)
72 * Number of extra elements we create space for when we grow host list
74 #define HOST_LIST_GROW_STEP 10
78 * A list entry for registered controllers list
80 struct RegisteredController
83 * The controller at which this host is registered
85 const struct GNUNET_TESTBED_Controller *controller;
88 * The next ptr for DLL
90 struct RegisteredController *next;
93 * The prev ptr for DLL
95 struct RegisteredController *prev;
100 * A slot to record time taken by an overlay connect operation
105 * A key to identify this timeslot
112 struct GNUNET_TIME_Relative time;
115 * Number of timing values accumulated
122 * Opaque handle to a host running experiments managed by the testing framework.
123 * The master process must be able to SSH to this host without password (via
126 struct GNUNET_TESTBED_Host
130 * The hostname of the host; NULL for localhost
132 const char *hostname;
135 * The username to be used for SSH login
137 const char *username;
140 * the configuration to use as a template while starting a controller on this
141 * host. Operation queue size specific to a host are also read from this
142 * configuration handle. After starting the controller, it points to the actual
143 * configuration with which the controller is running
145 struct GNUNET_CONFIGURATION_Handle *cfg;
148 * The head for the list of controllers where this host is registered
150 struct RegisteredController *rc_head;
153 * The tail for the list of controllers where this host is registered
155 struct RegisteredController *rc_tail;
158 * Operation queue for simultaneous overlay connect operations target at this
161 struct OperationQueue *opq_parallel_overlay_connect_operations;
164 * An array of timing slots; size should be equal to the current number of parallel
167 struct TimeSlot *tslots;
170 * Handle for SD calculations amount parallel overlay connect operation finish
173 struct SDHandle *poc_sd;
176 * The number of parallel overlay connects we do currently
178 unsigned int num_parallel_connects;
181 * Counter to indicate when all the available time slots are filled
183 unsigned int tslots_filled;
186 * Is a controller started on this host? FIXME: Is this needed?
188 int controller_started;
191 * Is this host locked by GNUNET_TESTBED_controller_start()?
196 * Global ID we use to refer to a host on the network
201 * The port which is to be used for SSH
209 * Array of available hosts
211 static struct GNUNET_TESTBED_Host **host_list;
214 * The size of the available hosts list
216 static unsigned int host_list_size;
220 * Lookup a host by ID.
222 * @param id global host ID assigned to the host; 0 is
223 * reserved to always mean 'localhost'
224 * @return handle to the host, NULL if host not found
226 struct GNUNET_TESTBED_Host *
227 GNUNET_TESTBED_host_lookup_by_id_ (uint32_t id)
229 if (host_list_size <= id)
231 return host_list[id];
236 * Create a host by ID; given this host handle, we could not
237 * run peers at the host, but we can talk about the host
240 * @param id global host ID assigned to the host; 0 is
241 * reserved to always mean 'localhost'
242 * @param cfg the configuration to use as a template while starting a controller
243 * on this host. Operation queue sizes specific to a host are also
244 * read from this configuration handle
245 * @return handle to the host, NULL on error
247 struct GNUNET_TESTBED_Host *
248 GNUNET_TESTBED_host_create_by_id_ (uint32_t id,
249 const struct GNUNET_CONFIGURATION_Handle
252 return GNUNET_TESTBED_host_create_with_id (id, NULL, NULL, cfg, 0);
257 * Obtain the host's unique global ID.
259 * @param host handle to the host, NULL means 'localhost'
260 * @return id global host ID assigned to the host (0 is
261 * 'localhost', but then obviously not globally unique)
264 GNUNET_TESTBED_host_get_id_ (const struct GNUNET_TESTBED_Host * host)
271 * Obtain the host's hostname.
273 * @param host handle to the host, NULL means 'localhost'
274 * @return hostname of the host
277 GNUNET_TESTBED_host_get_hostname (const struct GNUNET_TESTBED_Host *host)
279 return host->hostname;
284 * Obtain the host's username
286 * @param host handle to the host, NULL means 'localhost'
287 * @return username to login to the host
290 GNUNET_TESTBED_host_get_username_ (const struct GNUNET_TESTBED_Host *host)
292 return host->username;
297 * Obtain the host's ssh port
299 * @param host handle to the host, NULL means 'localhost'
300 * @return username to login to the host
303 GNUNET_TESTBED_host_get_ssh_port_ (const struct GNUNET_TESTBED_Host * host)
310 * Check whether a controller is already started on the given host
312 * @param host the handle to the host
313 * @return GNUNET_YES if the controller is already started; GNUNET_NO if not
316 GNUNET_TESTBED_host_controller_started (const struct GNUNET_TESTBED_Host *host)
318 return host->controller_started;
323 * Obtain the host's configuration template
325 * @param host handle to the host
326 * @return the host's configuration template
328 const struct GNUNET_CONFIGURATION_Handle *
329 GNUNET_TESTBED_host_get_cfg_ (const struct GNUNET_TESTBED_Host *host)
336 * Function to replace host's configuration
338 * @param host the host handle
339 * @param new_cfg the new configuration to replace the old one
342 GNUNET_TESTBED_host_replace_cfg_ (struct GNUNET_TESTBED_Host *host,
343 const struct GNUNET_CONFIGURATION_Handle *new_cfg)
345 GNUNET_CONFIGURATION_destroy (host->cfg);
346 host->cfg = GNUNET_CONFIGURATION_dup (new_cfg);
351 * Create a host to run peers and controllers on.
353 * @param id global host ID assigned to the host; 0 is
354 * reserved to always mean 'localhost'
355 * @param hostname name of the host, use "NULL" for localhost
356 * @param username username to use for the login; may be NULL
357 * @param cfg the configuration to use as a template while starting a controller
358 * on this host. Operation queue sizes specific to a host are also
359 * read from this configuration handle
360 * @param port port number to use for ssh; use 0 to let ssh decide
361 * @return handle to the host, NULL on error
363 struct GNUNET_TESTBED_Host *
364 GNUNET_TESTBED_host_create_with_id (uint32_t id, const char *hostname,
365 const char *username,
366 const struct GNUNET_CONFIGURATION_Handle
370 struct GNUNET_TESTBED_Host *host;
371 unsigned int new_size;
373 if ((id < host_list_size) && (NULL != host_list[id]))
375 LOG (GNUNET_ERROR_TYPE_WARNING, "Host with id: %u already created\n", id);
378 host = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Host));
379 host->hostname = (NULL != hostname) ? GNUNET_strdup (hostname) : NULL;
380 host->username = (NULL != username) ? GNUNET_strdup (username) : NULL;
382 host->port = (0 == port) ? 22 : port;
383 host->cfg = GNUNET_CONFIGURATION_dup (cfg);
384 host->opq_parallel_overlay_connect_operations =
385 GNUNET_TESTBED_operation_queue_create_ (0);
386 GNUNET_TESTBED_set_num_parallel_overlay_connects_ (host, 1);
387 host->poc_sd = GNUNET_TESTBED_SD_init_ (10);
388 new_size = host_list_size;
389 while (id >= new_size)
390 new_size += HOST_LIST_GROW_STEP;
391 if (new_size != host_list_size)
392 GNUNET_array_grow (host_list, host_list_size, new_size);
393 GNUNET_assert (id < host_list_size);
394 LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding host with id: %u\n", host->id);
395 host_list[id] = host;
401 * Create a host to run peers and controllers on.
403 * @param hostname name of the host, use "NULL" for localhost
404 * @param username username to use for the login; may be NULL
405 * @param cfg the configuration to use as a template while starting a controller
406 * on this host. Operation queue sizes specific to a host are also
407 * read from this configuration handle
408 * @param port port number to use for ssh; use 0 to let ssh decide
409 * @return handle to the host, NULL on error
411 struct GNUNET_TESTBED_Host *
412 GNUNET_TESTBED_host_create (const char *hostname, const char *username,
413 const struct GNUNET_CONFIGURATION_Handle *cfg,
416 static uint32_t uid_generator;
418 if (NULL == hostname)
419 return GNUNET_TESTBED_host_create_with_id (0, hostname, username,
421 return GNUNET_TESTBED_host_create_with_id (++uid_generator, hostname,
422 username, cfg, port);
427 * Load a set of hosts from a configuration file.
429 * @param filename file with the host specification
430 * @param cfg the configuration to use as a template while starting a controller
431 * on any of the loaded hosts. Operation queue sizes specific to a host
432 * are also read from this configuration handle
433 * @param hosts set to the hosts found in the file; caller must free this if
434 * number of hosts returned is greater than 0
435 * @return number of hosts returned in 'hosts', 0 on error
438 GNUNET_TESTBED_hosts_load_from_file (const char *filename,
439 const struct GNUNET_CONFIGURATION_Handle
441 struct GNUNET_TESTBED_Host ***hosts)
443 //struct GNUNET_TESTBED_Host **host_array;
444 struct GNUNET_TESTBED_Host *starting_host;
456 GNUNET_assert (NULL != filename);
457 if (GNUNET_YES != GNUNET_DISK_file_test (filename))
459 LOG (GNUNET_ERROR_TYPE_WARNING, _("Hosts file %s not found\n"), filename);
463 GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
467 LOG (GNUNET_ERROR_TYPE_WARNING, _("Hosts file %s has no data\n"), filename);
470 data = GNUNET_malloc (fs);
471 if (fs != GNUNET_DISK_fn_read (filename, data, fs))
474 LOG (GNUNET_ERROR_TYPE_WARNING, _("Hosts file %s cannot be read\n"),
480 starting_host = NULL;
482 while (offset < (fs - 1))
485 if (((data[offset] == '\n')) && (buf != &data[offset]))
489 SSCANF (buf, "%255[a-zA-Z0-9_]@%255[a-zA-Z0-9.]:%5hd", username,
493 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
494 "Successfully read host %s, port %d and user %s from file\n",
495 hostname, port, username);
496 /* We store hosts in a static list; hence we only require the starting
497 * host pointer in that list to access the newly created list of hosts */
498 if (NULL == starting_host)
499 starting_host = GNUNET_TESTBED_host_create (hostname, username, cfg,
502 (void) GNUNET_TESTBED_host_create (hostname, username, cfg, port);
506 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
507 "Error reading line `%s' in hostfile\n", buf);
508 buf = &data[offset + 1];
510 else if ((data[offset] == '\n') || (data[offset] == '\0'))
511 buf = &data[offset + 1];
514 if (NULL == starting_host)
516 *hosts = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Host *) * count);
517 memcpy (*hosts, &host_list[GNUNET_TESTBED_host_get_id_ (starting_host)],
518 sizeof (struct GNUNET_TESTBED_Host *) * count);
524 * Resolves a hostname using getaddrinfo
526 * @param host the hostname
527 * @return the string representing the IPv4 address of the given host; NULL upon error
530 simple_resolve (const char *host)
532 struct addrinfo *res;
533 const struct sockaddr_in *in_addr;
535 struct addrinfo hint;
538 hint.ai_family = AF_INET; /* IPv4 */
539 hint.ai_socktype = 0;
540 hint.ai_protocol = 0;
543 hint.ai_canonname = NULL;
545 hint.ai_flags = AI_NUMERICSERV;
547 LOG_DEBUG ("Resolving [%s]\n", host);
548 if (0 != (rc = getaddrinfo (host, "22", &hint, &res)))
550 LOG_GAI (GNUNET_ERROR_TYPE_ERROR, "getaddrinfo", rc);
553 GNUNET_assert (NULL != res);
554 GNUNET_assert (NULL != res->ai_addr);
555 GNUNET_assert (sizeof (struct sockaddr_in) == res->ai_addrlen);
556 in_addr = (const struct sockaddr_in *) res->ai_addr;
557 hostip = inet_ntoa (in_addr->sin_addr);
558 GNUNET_assert (NULL != hostip);
560 LOG_DEBUG ("Resolved [%s] to [%s]\n", host, hostip);
566 * Loads the set of host allocated by the LoadLeveler Job Scheduler. This
567 * function is only available when compiled with support for LoadLeveler and is
568 * used for running on the SuperMUC
570 * @param cfg the configuration to use as a template while starting a controller
571 * on any of the loaded hosts. Operation queue sizes specific to a host
572 * are also read from this configuration handle
573 * @param hosts set to the hosts found in the file; caller must free this if
574 * number of hosts returned is greater than 0
575 * @return number of hosts returned in 'hosts', 0 on error
578 GNUNET_TESTBED_hosts_load_from_loadleveler (const struct
579 GNUNET_CONFIGURATION_Handle *cfg,
580 struct GNUNET_TESTBED_Host ***hosts)
583 LOG (GNUNET_ERROR_TYPE_ERROR,
584 _("The function %s is only available when compiled with (--with-ll)\n"),
588 const char *hostfile;
594 struct GNUNET_TESTBED_Host **host_list;
606 unsigned int nhostaddrs;
608 if (NULL == (hostfile = getenv ("MP_SAVEHOSTFILE")))
613 if (GNUNET_SYSERR == GNUNET_DISK_file_size (hostfile, &size, GNUNET_YES,
624 buf = GNUNET_malloc (size + 1);
625 rsize = GNUNET_DISK_fn_read (hostfile, buf, (size_t) size);
626 if ( (GNUNET_SYSERR == rsize) || ((ssize_t) size != rsize) )
640 while (offset < size)
645 if ('!' == buf[offset])
651 if ('\n' == buf[offset])
655 if ('!' == buf[offset])
660 if ( (' ' == buf[offset])
661 || ('\t' == buf[offset])
662 || ('\r' == buf[offset]) )
667 hostname = &buf[offset];
671 if (isspace (buf[offset]))
674 for (host = 0; host < nhosts; host++)
675 if (0 == strcmp (hostnames[host], hostname))
679 LOG_DEBUG ("Adding host [%s]\n", hostname);
680 hostname = GNUNET_strdup (hostname);
681 GNUNET_array_append (hostnames, nhosts, hostname);
684 LOG_DEBUG ("Not adding host [%s] as it is already included\n", hostname);
692 GNUNET_free_non_null (buf);
693 if (NULL == hostnames)
695 for (host = 0; host < nhosts; host++)
697 hostip = simple_resolve (hostnames[host]);
703 GNUNET_array_append (hostaddrs, nhostaddrs, GNUNET_strdup (hostip));
705 GNUNET_assert (nhostaddrs == nhosts);
708 host_list = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Host *) * nhostaddrs);
709 for (host = 0; host < nhosts; host++)
710 host_list[host] = GNUNET_TESTBED_host_create (hostaddrs[host], NULL, cfg, 0);
714 for (host = 0; host < nhosts; host++)
715 GNUNET_free (hostnames[host]);
716 GNUNET_free(hostnames);
717 for (host = 0; (NULL != hostaddrs) && (host < nhostaddrs); host++)
718 GNUNET_free (hostaddrs[host]);
719 GNUNET_free (hostaddrs);
726 * Destroy a host handle. Must only be called once everything
727 * running on that host has been stopped.
729 * @param host handle to destroy
732 GNUNET_TESTBED_host_destroy (struct GNUNET_TESTBED_Host *host)
734 struct RegisteredController *rc;
737 GNUNET_assert (host->id < host_list_size);
738 GNUNET_assert (host_list[host->id] == host);
739 host_list[host->id] = NULL;
740 /* clear registered controllers list */
741 for (rc = host->rc_head; NULL != rc; rc = host->rc_head)
743 GNUNET_CONTAINER_DLL_remove (host->rc_head, host->rc_tail, rc);
746 GNUNET_free_non_null ((char *) host->username);
747 GNUNET_free_non_null ((char *) host->hostname);
748 GNUNET_TESTBED_operation_queue_destroy_
749 (host->opq_parallel_overlay_connect_operations);
750 GNUNET_TESTBED_SD_destroy_ (host->poc_sd);
751 GNUNET_free_non_null (host->tslots);
752 GNUNET_CONFIGURATION_destroy (host->cfg);
754 while (host_list_size >= HOST_LIST_GROW_STEP)
756 for (id = host_list_size - 1; id > host_list_size - HOST_LIST_GROW_STEP;
758 if (NULL != host_list[id])
760 if (id != host_list_size - HOST_LIST_GROW_STEP)
762 if (NULL != host_list[id])
764 host_list_size -= HOST_LIST_GROW_STEP;
767 GNUNET_realloc (host_list,
768 sizeof (struct GNUNET_TESTBED_Host *) * host_list_size);
773 * Marks a host as registered with a controller
775 * @param host the host to mark
776 * @param controller the controller at which this host is registered
779 GNUNET_TESTBED_mark_host_registered_at_ (struct GNUNET_TESTBED_Host *host,
780 const struct GNUNET_TESTBED_Controller
783 struct RegisteredController *rc;
785 for (rc = host->rc_head; NULL != rc; rc = rc->next)
787 if (controller == rc->controller) /* already registered at controller */
793 rc = GNUNET_malloc (sizeof (struct RegisteredController));
794 rc->controller = controller;
795 GNUNET_CONTAINER_DLL_insert_tail (host->rc_head, host->rc_tail, rc);
800 * Unmarks a host registered at a controller
802 * @param host the host to unmark
803 * @param controller the controller at which this host has to be unmarked
806 GNUNET_TESTBED_deregister_host_at_ (struct GNUNET_TESTBED_Host *host,
807 const struct GNUNET_TESTBED_Controller
810 struct RegisteredController *rc;
812 for (rc = host->rc_head; NULL != rc; rc=rc->next)
813 if (controller == rc->controller)
820 GNUNET_CONTAINER_DLL_remove (host->rc_head, host->rc_tail, rc);
826 * Checks whether a host has been registered
828 * @param host the host to check
829 * @param controller the controller at which host's registration is checked
830 * @return GNUNET_YES if registered; GNUNET_NO if not
833 GNUNET_TESTBED_is_host_registered_ (const struct GNUNET_TESTBED_Host *host,
834 const struct GNUNET_TESTBED_Controller
837 struct RegisteredController *rc;
839 for (rc = host->rc_head; NULL != rc; rc = rc->next)
841 if (controller == rc->controller) /* already registered at controller */
851 * Handle for controller process
853 struct GNUNET_TESTBED_ControllerProc
858 struct GNUNET_HELPER_Handle *helper;
861 * The arguments used to start the helper
866 * The host where the helper is run
868 struct GNUNET_TESTBED_Host *host;
871 * The controller error callback
873 GNUNET_TESTBED_ControllerStatusCallback cb;
876 * The closure for the above callback
881 * The send handle for the helper
883 struct GNUNET_HELPER_SendHandle *shandle;
886 * The message corresponding to send handle
888 struct GNUNET_MessageHeader *msg;
894 * Function to copy NULL terminated list of arguments
896 * @param argv the NULL terminated list of arguments. Cannot be NULL.
897 * @return the copied NULL terminated arguments
900 copy_argv (const char *const *argv)
905 GNUNET_assert (NULL != argv);
906 for (argp = 0; NULL != argv[argp]; argp++) ;
907 argv_dup = GNUNET_malloc (sizeof (char *) * (argp + 1));
908 for (argp = 0; NULL != argv[argp]; argp++)
909 argv_dup[argp] = strdup (argv[argp]);
915 * Function to join NULL terminated list of arguments
917 * @param argv1 the NULL terminated list of arguments. Cannot be NULL.
918 * @param argv2 the NULL terminated list of arguments. Cannot be NULL.
919 * @return the joined NULL terminated arguments
922 join_argv (const char *const *argv1, const char *const *argv2)
931 for (cnt = 0; NULL != argv1[cnt]; cnt++)
933 argv = GNUNET_strdup (argv1[cnt]);
934 GNUNET_array_append (argvj, carg, argv);
936 for (cnt = 0; NULL != argv2[cnt]; cnt++)
938 argv = GNUNET_strdup (argv2[cnt]);
939 GNUNET_array_append (argvj, carg, argv);
941 GNUNET_array_append (argvj, carg, NULL);
947 * Frees the given NULL terminated arguments
949 * @param argv the NULL terminated list of arguments
952 free_argv (char **argv)
956 for (argp = 0; NULL != argv[argp]; argp++)
957 GNUNET_free (argv[argp]);
963 * Generates arguments for opening a remote shell. Builds up the arguments
964 * from the environment variable GNUNET_TESTBED_RSH_CMD. The variable
965 * should not mention `-p' (port) option and destination address as these will
966 * be set locally in the function from its parameteres. If the environmental
967 * variable is not found then it defaults to `ssh -o BatchMode=yes -o
968 * NoHostAuthenticationForLocalhost=yes'
970 * @param port the destination port number
971 * @param dst the destination address
972 * @return NULL terminated list of arguments
975 gen_rsh_args (const char *port, const char *dst)
977 static const char *default_ssh_args[] = {
982 "NoHostAuthenticationForLocalhost=yes",
992 if (NULL != (ssh_cmd = getenv ("GNUNET_TESTBED_RSH_CMD")))
994 ssh_cmd = GNUNET_strdup (ssh_cmd);
995 ssh_cmd_cp = ssh_cmd;
996 for (cnt = 0; NULL != (arg = strtok (ssh_cmd, " ")); ssh_cmd = NULL)
997 GNUNET_array_append (ssh_args, cnt, GNUNET_strdup (arg));
998 GNUNET_free (ssh_cmd_cp);
1002 ssh_args = copy_argv (default_ssh_args);
1003 cnt = (sizeof (default_ssh_args)) / (sizeof (const char *));
1004 GNUNET_array_grow (ssh_args, cnt, cnt - 1);
1006 GNUNET_array_append (ssh_args, cnt, GNUNET_strdup ("-p"));
1007 GNUNET_array_append (ssh_args, cnt, GNUNET_strdup (port));
1008 GNUNET_array_append (ssh_args, cnt, GNUNET_strdup (dst));
1009 GNUNET_array_append (ssh_args, cnt, NULL);
1015 * Generates the arguments needed for executing the given binary in a remote
1016 * shell. Builds the arguments from the environmental variable
1017 * GNUNET_TETSBED_RSH_CMD_SUFFIX. If the environmental variable is not found,
1018 * only the given binary name will be present in the returned arguments
1020 * @param append_args the arguments to append after generating the suffix
1021 * arguments. Can be NULL; if not must be NULL terminated 'char *' array
1022 * @return NULL-terminated args
1025 gen_rsh_suffix_args (const char * const *append_args)
1029 char *rshell_cmd_cp;
1032 unsigned int append_cnt;
1036 if (NULL != (rshell_cmd = getenv ("GNUNET_TESTBED_RSH_CMD_SUFFIX")))
1038 rshell_cmd = GNUNET_strdup (rshell_cmd);
1039 rshell_cmd_cp = rshell_cmd;
1040 for (; NULL != (arg = strtok (rshell_cmd, " ")); rshell_cmd = NULL)
1041 GNUNET_array_append (rshell_args, cnt, GNUNET_strdup (arg));
1042 GNUNET_free (rshell_cmd_cp);
1044 if (NULL != append_args)
1046 for (append_cnt = 0; NULL != append_args[append_cnt]; append_cnt++)
1047 GNUNET_array_append (rshell_args, cnt, GNUNET_strdup (append_args[append_cnt]));
1049 GNUNET_array_append (rshell_args, cnt, NULL);
1055 * Functions with this signature are called whenever a
1056 * complete message is received by the tokenizer.
1058 * Do not call GNUNET_SERVER_mst_destroy in callback
1060 * @param cls closure
1061 * @param client identification of the client
1062 * @param message the actual message
1064 * @return GNUNET_OK on success, GNUNET_SYSERR to stop further processing
1067 helper_mst (void *cls, void *client, const struct GNUNET_MessageHeader *message)
1069 struct GNUNET_TESTBED_ControllerProc *cp = cls;
1070 const struct GNUNET_TESTBED_HelperReply *msg;
1071 const char *hostname;
1074 uLongf xconfig_size;
1076 msg = (const struct GNUNET_TESTBED_HelperReply *) message;
1077 GNUNET_assert (sizeof (struct GNUNET_TESTBED_HelperReply) <
1078 ntohs (msg->header.size));
1079 GNUNET_assert (GNUNET_MESSAGE_TYPE_TESTBED_HELPER_REPLY ==
1080 ntohs (msg->header.type));
1081 config_size = (uLongf) ntohs (msg->config_size);
1083 (uLongf) (ntohs (msg->header.size) -
1084 sizeof (struct GNUNET_TESTBED_HelperReply));
1085 config = GNUNET_malloc (config_size);
1086 GNUNET_assert (Z_OK ==
1087 uncompress ((Bytef *) config, &config_size,
1088 (const Bytef *) &msg[1], xconfig_size));
1089 /* Replace the configuration template present in the host with the
1090 controller's running configuration */
1091 GNUNET_CONFIGURATION_destroy (cp->host->cfg);
1092 cp->host->cfg = GNUNET_CONFIGURATION_create ();
1093 GNUNET_assert (GNUNET_CONFIGURATION_deserialize
1094 (cp->host->cfg, config, config_size, GNUNET_NO));
1095 GNUNET_free (config);
1096 if ((NULL == cp->host) ||
1097 (NULL == (hostname = GNUNET_TESTBED_host_get_hostname (cp->host))))
1098 hostname = "localhost";
1099 /* Change the hostname so that we can connect to it */
1100 GNUNET_CONFIGURATION_set_value_string (cp->host->cfg, "testbed", "hostname",
1102 cp->host->locked = GNUNET_NO;
1103 cp->host->controller_started = GNUNET_YES;
1104 cp->cb (cp->cls, cp->host->cfg, GNUNET_OK);
1110 * Continuation function from GNUNET_HELPER_send()
1112 * @param cls closure
1113 * @param result GNUNET_OK on success,
1114 * GNUNET_NO if helper process died
1115 * GNUNET_SYSERR during GNUNET_HELPER_stop
1118 clear_msg (void *cls, int result)
1120 struct GNUNET_TESTBED_ControllerProc *cp = cls;
1122 GNUNET_assert (NULL != cp->shandle);
1124 GNUNET_free (cp->msg);
1129 * Callback that will be called when the helper process dies. This is not called
1130 * when the helper process is stoped using GNUNET_HELPER_stop()
1132 * @param cls the closure from GNUNET_HELPER_start()
1135 helper_exp_cb (void *cls)
1137 struct GNUNET_TESTBED_ControllerProc *cp = cls;
1138 GNUNET_TESTBED_ControllerStatusCallback cb;
1144 GNUNET_TESTBED_controller_stop (cp);
1146 cb (cb_cls, NULL, GNUNET_SYSERR);
1151 * Starts a controller process at the given host. The given host's configration
1152 * is used as a Template configuration to use for the remote controller; the
1153 * remote controller will be started with a slightly modified configuration
1154 * (port numbers, unix domain sockets and service home values are changed as per
1155 * TESTING library on the remote host). The modified configuration replaces the
1156 * host's existing configuration before signalling success through the
1157 * GNUNET_TESTBED_ControllerStatusCallback()
1159 * @param trusted_ip the ip address of the controller which will be set as TRUSTED
1160 * HOST(all connections form this ip are permitted by the testbed) when
1161 * starting testbed controller at host. This can either be a single ip
1162 * address or a network address in CIDR notation.
1163 * @param host the host where the controller has to be started. CANNOT be NULL.
1164 * @param cb function called when the controller is successfully started or
1165 * dies unexpectedly; GNUNET_TESTBED_controller_stop shouldn't be
1166 * called if cb is called with GNUNET_SYSERR as status. Will never be
1167 * called in the same task as 'GNUNET_TESTBED_controller_start'
1168 * (synchronous errors will be signalled by returning NULL). This
1169 * parameter cannot be NULL.
1170 * @param cls closure for above callbacks
1171 * @return the controller process handle, NULL on errors
1173 struct GNUNET_TESTBED_ControllerProc *
1174 GNUNET_TESTBED_controller_start (const char *trusted_ip,
1175 struct GNUNET_TESTBED_Host *host,
1176 GNUNET_TESTBED_ControllerStatusCallback cb,
1179 struct GNUNET_TESTBED_ControllerProc *cp;
1180 struct GNUNET_TESTBED_HelperInit *msg;
1181 const struct GNUNET_CONFIGURATION_Handle *cfg;
1182 const char *hostname;
1183 static char *const binary_argv[] = {
1184 HELPER_TESTBED_BINARY, NULL
1187 GNUNET_assert (NULL != host);
1188 GNUNET_assert (NULL != (cfg = GNUNET_TESTBED_host_get_cfg_ (host)));
1190 API_VIOLATION (GNUNET_NO == host->locked,
1191 "Host is already locked by a previous call to GNUNET_TESTBED_controller_start()");
1192 host->locked = GNUNET_YES;
1193 API_VIOLATION (GNUNET_NO == host->controller_started,
1194 "Attempting to start a controller on a host which is already started a controller");
1195 cp = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_ControllerProc));
1196 if (0 == GNUNET_TESTBED_host_get_id_ (host))
1199 GNUNET_HELPER_start (GNUNET_YES, HELPER_TESTBED_BINARY, binary_argv,
1200 &helper_mst, &helper_exp_cb, cp);
1204 char *helper_binary_path_args[2];
1206 char **rsh_suffix_args;
1207 const char *username;
1211 username = GNUNET_TESTBED_host_get_username_ (host);
1212 hostname = GNUNET_TESTBED_host_get_hostname (host);
1213 GNUNET_asprintf (&port, "%u", GNUNET_TESTBED_host_get_ssh_port_ (host));
1214 if (NULL == username)
1215 GNUNET_asprintf (&dst, "%s", hostname);
1217 GNUNET_asprintf (&dst, "%s@%s", username, hostname);
1218 LOG_DEBUG ("Starting SSH to destination %s\n", dst);
1221 GNUNET_CONFIGURATION_get_value_string (cfg, "testbed",
1222 "HELPER_BINARY_PATH",
1223 &helper_binary_path_args[0]))
1224 helper_binary_path_args[0] =
1225 GNUNET_OS_get_libexec_binary_path (HELPER_TESTBED_BINARY);
1226 helper_binary_path_args[1] = NULL;
1227 rsh_args = gen_rsh_args (port, dst);
1228 rsh_suffix_args = gen_rsh_suffix_args ((const char **) helper_binary_path_args);
1230 join_argv ((const char **) rsh_args, (const char **) rsh_suffix_args);
1231 free_argv (rsh_args);
1232 free_argv (rsh_suffix_args);
1236 GNUNET_HELPER_start (GNUNET_NO, cp->helper_argv[0], cp->helper_argv, &helper_mst,
1237 &helper_exp_cb, cp);
1238 GNUNET_free (helper_binary_path_args[0]);
1240 if (NULL == cp->helper)
1242 if (NULL != cp->helper_argv)
1243 free_argv (cp->helper_argv);
1250 msg = GNUNET_TESTBED_create_helper_init_msg_ (trusted_ip, hostname, cfg);
1251 cp->msg = &msg->header;
1253 GNUNET_HELPER_send (cp->helper, &msg->header, GNUNET_NO, &clear_msg, cp);
1254 if (NULL == cp->shandle)
1257 GNUNET_TESTBED_controller_stop (cp);
1265 * Sends termination signal to the controller's helper process
1267 * @param cproc the handle to the controller's helper process
1270 GNUNET_TESTBED_controller_kill_ (struct GNUNET_TESTBED_ControllerProc *cproc)
1272 if (NULL != cproc->shandle)
1273 GNUNET_HELPER_send_cancel (cproc->shandle);
1274 if (NULL != cproc->helper)
1275 GNUNET_HELPER_kill (cproc->helper, GNUNET_YES);
1280 * Cleans-up the controller's helper process handle
1282 * @param cproc the handle to the controller's helper process
1285 GNUNET_TESTBED_controller_destroy_ (struct GNUNET_TESTBED_ControllerProc *cproc)
1287 if (NULL != cproc->helper)
1289 GNUNET_break (GNUNET_OK == GNUNET_HELPER_wait (cproc->helper));
1290 GNUNET_HELPER_destroy (cproc->helper);
1292 if (NULL != cproc->helper_argv)
1293 free_argv (cproc->helper_argv);
1294 cproc->host->controller_started = GNUNET_NO;
1295 cproc->host->locked = GNUNET_NO;
1296 GNUNET_free (cproc);
1301 * Stop the controller process (also will terminate all peers and controllers
1302 * dependent on this controller). This function blocks until the testbed has
1303 * been fully terminated (!). The controller status cb from
1304 * GNUNET_TESTBED_controller_start() will not be called.
1306 * @param cproc the controller process handle
1309 GNUNET_TESTBED_controller_stop (struct GNUNET_TESTBED_ControllerProc *cproc)
1311 GNUNET_TESTBED_controller_kill_ (cproc);
1312 GNUNET_TESTBED_controller_destroy_ (cproc);
1317 * The handle for whether a host is habitable or not
1319 struct GNUNET_TESTBED_HostHabitableCheckHandle
1324 const struct GNUNET_TESTBED_Host *host;
1327 * The callback to call once we have the status
1329 GNUNET_TESTBED_HostHabitableCallback cb;
1332 * The callback closure
1337 * The process handle for the SSH process
1339 struct GNUNET_OS_Process *auxp;
1342 * The arguments used to start the helper
1347 * Task id for the habitability check task
1349 GNUNET_SCHEDULER_TaskIdentifier habitability_check_task;
1352 * How long we wait before checking the process status. Should grow
1355 struct GNUNET_TIME_Relative wait_time;
1361 * Task for checking whether a host is habitable or not
1363 * @param cls GNUNET_TESTBED_HostHabitableCheckHandle
1364 * @param tc the scheduler task context
1367 habitability_check (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1369 struct GNUNET_TESTBED_HostHabitableCheckHandle *h = cls;
1371 GNUNET_TESTBED_HostHabitableCallback cb;
1372 const struct GNUNET_TESTBED_Host *host;
1374 enum GNUNET_OS_ProcessStatusType type;
1377 h->habitability_check_task = GNUNET_SCHEDULER_NO_TASK;
1378 ret = GNUNET_OS_process_status (h->auxp, &type, &code);
1379 if (GNUNET_SYSERR == ret)
1385 if (GNUNET_NO == ret)
1387 h->wait_time = GNUNET_TIME_STD_BACKOFF (h->wait_time);
1388 h->habitability_check_task =
1389 GNUNET_SCHEDULER_add_delayed (h->wait_time, &habitability_check, h);
1392 GNUNET_OS_process_destroy (h->auxp);
1394 ret = (0 != code) ? GNUNET_NO : GNUNET_YES;
1397 if (NULL != h->auxp)
1398 GNUNET_OS_process_destroy (h->auxp);
1402 free_argv (h->helper_argv);
1405 cb (cb_cls, host, ret);
1410 * Checks whether a host can be used to start testbed service
1412 * @param host the host to check
1413 * @param config the configuration handle to lookup the path of the testbed
1415 * @param cb the callback to call to inform about habitability of the given host
1416 * @param cb_cls the closure for the callback
1417 * @return NULL upon any error or a handle which can be passed to
1418 * GNUNET_TESTBED_is_host_habitable_cancel()
1420 struct GNUNET_TESTBED_HostHabitableCheckHandle *
1421 GNUNET_TESTBED_is_host_habitable (const struct GNUNET_TESTBED_Host *host,
1422 const struct GNUNET_CONFIGURATION_Handle
1424 GNUNET_TESTBED_HostHabitableCallback cb,
1427 struct GNUNET_TESTBED_HostHabitableCheckHandle *h;
1429 char **rsh_suffix_args;
1431 const char *hostname;
1435 h = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_HostHabitableCheckHandle));
1439 hostname = (NULL == host->hostname) ? "127.0.0.1" : host->hostname;
1440 if (NULL == host->username)
1441 dst = GNUNET_strdup (hostname);
1443 GNUNET_asprintf (&dst, "%s@%s", host->username, hostname);
1445 GNUNET_CONFIGURATION_get_value_string (config, "testbed",
1446 "HELPER_BINARY_PATH",
1449 GNUNET_OS_get_libexec_binary_path (HELPER_TESTBED_BINARY);
1450 GNUNET_asprintf (&port, "%u", host->port);
1451 rsh_args = gen_rsh_args (port, dst);
1456 stat_args[0] = "stat";
1457 stat_args[2] = NULL;
1458 rsh_suffix_args = gen_rsh_suffix_args ((const char **) stat_args);
1459 GNUNET_free (stat_args[1]);
1460 h->helper_argv = join_argv ((const char **) rsh_args,
1461 (const char **) rsh_suffix_args);
1462 free_argv (rsh_suffix_args);
1463 free_argv (rsh_args);
1465 GNUNET_OS_start_process_vap (GNUNET_NO, GNUNET_OS_INHERIT_STD_ERR, NULL,
1466 NULL, h->helper_argv[0], h->helper_argv);
1467 if (NULL == h->auxp)
1469 GNUNET_break (0); /* Cannot exec SSH? */
1473 h->wait_time = GNUNET_TIME_STD_BACKOFF (h->wait_time);
1474 h->habitability_check_task =
1475 GNUNET_SCHEDULER_add_delayed (h->wait_time, &habitability_check, h);
1481 * Function to cancel a request started using GNUNET_TESTBED_is_host_habitable()
1483 * @param handle the habitability check handle
1486 GNUNET_TESTBED_is_host_habitable_cancel (struct
1487 GNUNET_TESTBED_HostHabitableCheckHandle
1490 GNUNET_SCHEDULER_cancel (handle->habitability_check_task);
1491 (void) GNUNET_OS_process_kill (handle->auxp, SIGTERM);
1492 (void) GNUNET_OS_process_wait (handle->auxp);
1493 GNUNET_OS_process_destroy (handle->auxp);
1494 free_argv (handle->helper_argv);
1495 GNUNET_free (handle);
1500 * handle for host registration
1502 struct GNUNET_TESTBED_HostRegistrationHandle
1505 * The host being registered
1507 struct GNUNET_TESTBED_Host *host;
1510 * The controller at which this host is being registered
1512 struct GNUNET_TESTBED_Controller *c;
1515 * The Registartion completion callback
1517 GNUNET_TESTBED_HostRegistrationCompletion cc;
1520 * The closure for above callback
1527 * Register a host with the controller
1529 * @param controller the controller handle
1530 * @param host the host to register
1531 * @param cc the completion callback to call to inform the status of
1532 * registration. After calling this callback the registration handle
1533 * will be invalid. Cannot be NULL.
1534 * @param cc_cls the closure for the cc
1535 * @return handle to the host registration which can be used to cancel the
1538 struct GNUNET_TESTBED_HostRegistrationHandle *
1539 GNUNET_TESTBED_register_host (struct GNUNET_TESTBED_Controller *controller,
1540 struct GNUNET_TESTBED_Host *host,
1541 GNUNET_TESTBED_HostRegistrationCompletion cc,
1544 struct GNUNET_TESTBED_HostRegistrationHandle *rh;
1545 struct GNUNET_TESTBED_AddHostMessage *msg;
1546 const char *username;
1547 const char *hostname;
1554 uint16_t username_length;
1555 uint16_t hostname_length;
1557 if (NULL != controller->rh)
1559 hostname = GNUNET_TESTBED_host_get_hostname (host);
1560 if (GNUNET_YES == GNUNET_TESTBED_is_host_registered_ (host, controller))
1562 LOG (GNUNET_ERROR_TYPE_WARNING, "Host hostname: %s already registered\n",
1563 (NULL == hostname) ? "localhost" : hostname);
1566 rh = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_HostRegistrationHandle));
1569 GNUNET_assert (NULL != cc);
1571 rh->cc_cls = cc_cls;
1572 controller->rh = rh;
1573 username = GNUNET_TESTBED_host_get_username_ (host);
1574 username_length = 0;
1575 if (NULL != username)
1576 username_length = strlen (username);
1577 GNUNET_assert (NULL != hostname); /* Hostname must be present */
1578 hostname_length = strlen (hostname);
1579 GNUNET_assert (NULL != host->cfg);
1580 config = GNUNET_CONFIGURATION_serialize (host->cfg, &config_size);
1581 cc_size = GNUNET_TESTBED_compress_config_ (config, config_size, &cconfig);
1582 GNUNET_free (config);
1583 msg_size = (sizeof (struct GNUNET_TESTBED_AddHostMessage));
1584 msg_size += username_length;
1585 msg_size += hostname_length;
1586 msg_size += cc_size;
1587 msg = GNUNET_malloc (msg_size);
1588 msg->header.size = htons (msg_size);
1589 msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST);
1590 msg->host_id = htonl (GNUNET_TESTBED_host_get_id_ (host));
1591 msg->ssh_port = htons (GNUNET_TESTBED_host_get_ssh_port_ (host));
1593 if (NULL != username)
1595 msg->username_length = htons (username_length);
1596 ptr = memcpy (ptr, username, username_length);
1597 ptr += username_length;
1599 msg->hostname_length = htons (hostname_length);
1600 ptr = memcpy (ptr, hostname, hostname_length);
1601 ptr += hostname_length;
1602 msg->config_size = htons (config_size);
1603 ptr = memcpy (ptr, cconfig, cc_size);
1605 GNUNET_assert ((ptr - (void *) msg) == msg_size);
1606 GNUNET_free (cconfig);
1607 GNUNET_TESTBED_queue_message_ (controller,
1608 (struct GNUNET_MessageHeader *) msg);
1614 * Cancel the pending registration. Note that if the registration message is
1615 * already sent to the service the cancellation has only the effect that the
1616 * registration completion callback for the registration is never called.
1618 * @param handle the registration handle to cancel
1621 GNUNET_TESTBED_cancel_registration (struct GNUNET_TESTBED_HostRegistrationHandle
1624 if (handle != handle->c->rh)
1629 handle->c->rh = NULL;
1630 GNUNET_free (handle);
1635 * Initializes the operation queue for parallel overlay connects
1637 * @param h the host handle
1638 * @param npoc the number of parallel overlay connects - the queue size
1641 GNUNET_TESTBED_set_num_parallel_overlay_connects_ (struct
1642 GNUNET_TESTBED_Host *h,
1645 //fprintf (stderr, "%d", npoc);
1646 GNUNET_free_non_null (h->tslots);
1647 h->tslots_filled = 0;
1648 h->num_parallel_connects = npoc;
1649 h->tslots = GNUNET_malloc (npoc * sizeof (struct TimeSlot));
1650 GNUNET_TESTBED_operation_queue_reset_max_active_
1651 (h->opq_parallel_overlay_connect_operations, npoc);
1656 * Returns a timing slot which will be exclusively locked
1658 * @param h the host handle
1659 * @param key a pointer which is associated to the returned slot; should not be
1660 * NULL. It serves as a key to determine the correct owner of the slot
1661 * @return the time slot index in the array of time slots in the controller
1665 GNUNET_TESTBED_get_tslot_ (struct GNUNET_TESTBED_Host *h, void *key)
1669 GNUNET_assert (NULL != h->tslots);
1670 GNUNET_assert (NULL != key);
1671 for (slot = 0; slot < h->num_parallel_connects; slot++)
1672 if (NULL == h->tslots[slot].key)
1674 h->tslots[slot].key = key;
1677 GNUNET_assert (0); /* We should always find a free tslot */
1682 * Decides whether any change in the number of parallel overlay connects is
1683 * necessary to adapt to the load on the system
1685 * @param h the host handle
1688 decide_npoc (struct GNUNET_TESTBED_Host *h)
1690 struct GNUNET_TIME_Relative avg;
1695 if (h->tslots_filled != h->num_parallel_connects)
1697 avg = GNUNET_TIME_UNIT_ZERO;
1699 for (slot = 0; slot < h->num_parallel_connects; slot++)
1701 avg = GNUNET_TIME_relative_add (avg, h->tslots[slot].time);
1702 nvals += h->tslots[slot].nvals;
1704 GNUNET_assert (nvals >= h->num_parallel_connects);
1705 avg = GNUNET_TIME_relative_divide (avg, nvals);
1706 GNUNET_assert (GNUNET_TIME_UNIT_FOREVER_REL.rel_value != avg.rel_value);
1707 sd = GNUNET_TESTBED_SD_deviation_factor_ (h->poc_sd, (unsigned int) avg.rel_value);
1709 (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
1710 h->num_parallel_connects)) )
1711 GNUNET_TESTBED_SD_add_data_ (h->poc_sd, (unsigned int) avg.rel_value);
1712 if (GNUNET_SYSERR == sd)
1714 GNUNET_TESTBED_set_num_parallel_overlay_connects_ (h,
1715 h->num_parallel_connects);
1718 GNUNET_assert (0 <= sd);
1721 GNUNET_TESTBED_set_num_parallel_overlay_connects_ (h,
1722 h->num_parallel_connects
1728 GNUNET_TESTBED_set_num_parallel_overlay_connects_ (h,
1729 h->num_parallel_connects
1733 if (1 == h->num_parallel_connects)
1735 GNUNET_TESTBED_set_num_parallel_overlay_connects_ (h, 1);
1740 GNUNET_TESTBED_set_num_parallel_overlay_connects_ (h,
1741 h->num_parallel_connects
1745 GNUNET_TESTBED_set_num_parallel_overlay_connects_ (h,
1746 h->num_parallel_connects /
1752 * Releases a time slot thus making it available for be used again
1754 * @param h the host handle
1755 * @param index the index of the the time slot
1756 * @param key the key to prove ownership of the timeslot
1757 * @return GNUNET_YES if the time slot is successfully removed; GNUNET_NO if the
1758 * time slot cannot be removed - this could be because of the index
1759 * greater than existing number of time slots or `key' being different
1762 GNUNET_TESTBED_release_time_slot_ (struct GNUNET_TESTBED_Host *h,
1763 unsigned int index, void *key)
1765 struct TimeSlot *slot;
1767 GNUNET_assert (NULL != key);
1768 if (index >= h->num_parallel_connects)
1770 slot = &h->tslots[index];
1771 if (key != slot->key)
1779 * Function to update a time slot
1781 * @param h the host handle
1782 * @param index the index of the time slot to update
1783 * @param key the key to identify ownership of the slot
1784 * @param time the new time
1785 * @param failed should this reading be treated as coming from a fail event
1788 GNUNET_TESTBED_update_time_slot_ (struct GNUNET_TESTBED_Host *h,
1789 unsigned int index, void *key,
1790 struct GNUNET_TIME_Relative time, int failed)
1792 struct TimeSlot *slot;
1794 if (GNUNET_YES == failed)
1796 if (1 == h->num_parallel_connects)
1798 GNUNET_TESTBED_set_num_parallel_overlay_connects_ (h, 1);
1801 GNUNET_TESTBED_set_num_parallel_overlay_connects_ (h,
1802 h->num_parallel_connects
1805 if (GNUNET_NO == GNUNET_TESTBED_release_time_slot_ (h, index, key))
1807 slot = &h->tslots[index];
1809 if (GNUNET_TIME_UNIT_ZERO.rel_value == slot->time.rel_value)
1816 slot->time = GNUNET_TIME_relative_add (slot->time, time);
1821 * Queues the given operation in the queue for parallel overlay connects of the
1824 * @param h the host handle
1825 * @param op the operation to queue in the given host's parally overlay connect
1829 GNUNET_TESTBED_host_queue_oc_ (struct GNUNET_TESTBED_Host *h,
1830 struct GNUNET_TESTBED_Operation *op)
1832 GNUNET_TESTBED_operation_queue_insert_
1833 (h->opq_parallel_overlay_connect_operations, op);
1838 * Handler for GNUNET_MESSAGE_TYPE_TESTBED_ADDHOSTCONFIRM message from
1839 * controller (testbed service)
1841 * @param c the controller handler
1842 * @param msg message received
1843 * @return GNUNET_YES if we can continue receiving from service; GNUNET_NO if
1847 GNUNET_TESTBED_host_handle_addhostconfirm_ (struct GNUNET_TESTBED_Controller *c,
1849 GNUNET_TESTBED_HostConfirmedMessage
1852 struct GNUNET_TESTBED_HostRegistrationHandle *rh;
1861 if (GNUNET_TESTBED_host_get_id_ (rh->host) != ntohl (msg->host_id))
1863 LOG_DEBUG ("Mismatch in host id's %u, %u of host confirm msg\n",
1864 GNUNET_TESTBED_host_get_id_ (rh->host), ntohl (msg->host_id));
1868 msg_size = ntohs (msg->header.size);
1869 if (sizeof (struct GNUNET_TESTBED_HostConfirmedMessage) == msg_size)
1871 LOG_DEBUG ("Host %u successfully registered\n", ntohl (msg->host_id));
1872 GNUNET_TESTBED_mark_host_registered_at_ (rh->host, c);
1873 rh->cc (rh->cc_cls, NULL);
1877 /* We have an error message */
1878 emsg = (char *) &msg[1];
1880 emsg[msg_size - sizeof (struct GNUNET_TESTBED_HostConfirmedMessage)])
1886 LOG (GNUNET_ERROR_TYPE_ERROR, _("Adding host %u failed with error: %s\n"),
1887 ntohl (msg->host_id), emsg);
1888 rh->cc (rh->cc_cls, emsg);
1893 /* end of testbed_api_hosts.c */