2 This file is part of GNUnet
3 Copyright (C) 2008--2013 GNUnet e.V.
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., 51 Franklin Street, Fifth Floor,
18 Boston, MA 02110-1301, 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"
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 * Opaque handle to a host running experiments managed by the testing framework.
101 * The master process must be able to SSH to this host without password (via
104 struct GNUNET_TESTBED_Host
108 * The hostname of the host; NULL for localhost
110 const char *hostname;
113 * The username to be used for SSH login
115 const char *username;
118 * the configuration to use as a template while starting a controller on this
119 * host. Operation queue size specific to a host are also read from this
120 * configuration handle. After starting the controller, it points to the actual
121 * configuration with which the controller is running
123 struct GNUNET_CONFIGURATION_Handle *cfg;
126 * The head for the list of controllers where this host is registered
128 struct RegisteredController *rc_head;
131 * The tail for the list of controllers where this host is registered
133 struct RegisteredController *rc_tail;
136 * Operation queue for simultaneous overlay connect operations target at this
139 struct OperationQueue *opq_parallel_overlay_connect_operations;
142 * Is a controller started on this host? FIXME: Is this needed?
144 int controller_started;
147 * Is this host locked by GNUNET_TESTBED_controller_start()?
152 * Global ID we use to refer to a host on the network
157 * The port which is to be used for SSH
165 * Array of available hosts
167 static struct GNUNET_TESTBED_Host **host_list;
170 * The size of the available hosts list
172 static unsigned int host_list_size;
176 * Lookup a host by ID.
178 * @param id global host ID assigned to the host; 0 is
179 * reserved to always mean 'localhost'
180 * @return handle to the host, NULL if host not found
182 struct GNUNET_TESTBED_Host *
183 GNUNET_TESTBED_host_lookup_by_id_ (uint32_t id)
185 if (host_list_size <= id)
187 return host_list[id];
192 * Create a host by ID; given this host handle, we could not
193 * run peers at the host, but we can talk about the host
196 * @param id global host ID assigned to the host; 0 is
197 * reserved to always mean 'localhost'
198 * @param cfg the configuration to use as a template while starting a controller
199 * on this host. Operation queue sizes specific to a host are also
200 * read from this configuration handle
201 * @return handle to the host, NULL on error
203 struct GNUNET_TESTBED_Host *
204 GNUNET_TESTBED_host_create_by_id_ (uint32_t id,
205 const struct GNUNET_CONFIGURATION_Handle
208 return GNUNET_TESTBED_host_create_with_id (id, NULL, NULL, cfg, 0);
213 * Obtain the host's unique global ID.
215 * @param host handle to the host, NULL means 'localhost'
216 * @return id global host ID assigned to the host (0 is
217 * 'localhost', but then obviously not globally unique)
220 GNUNET_TESTBED_host_get_id_ (const struct GNUNET_TESTBED_Host * host)
227 * Obtain the host's hostname.
229 * @param host handle to the host, NULL means 'localhost'
230 * @return hostname of the host
233 GNUNET_TESTBED_host_get_hostname (const struct GNUNET_TESTBED_Host *host)
235 return host->hostname;
240 * Obtain the host's username
242 * @param host handle to the host, NULL means 'localhost'
243 * @return username to login to the host
246 GNUNET_TESTBED_host_get_username_ (const struct GNUNET_TESTBED_Host *host)
248 return host->username;
253 * Obtain the host's ssh port
255 * @param host handle to the host, NULL means 'localhost'
256 * @return username to login to the host
259 GNUNET_TESTBED_host_get_ssh_port_ (const struct GNUNET_TESTBED_Host * host)
266 * Check whether a controller is already started on the given host
268 * @param host the handle to the host
269 * @return GNUNET_YES if the controller is already started; GNUNET_NO if not
272 GNUNET_TESTBED_host_controller_started (const struct GNUNET_TESTBED_Host *host)
274 return host->controller_started;
279 * Obtain the host's configuration template
281 * @param host handle to the host
282 * @return the host's configuration template
284 const struct GNUNET_CONFIGURATION_Handle *
285 GNUNET_TESTBED_host_get_cfg_ (const struct GNUNET_TESTBED_Host *host)
292 * Function to replace host's configuration
294 * @param host the host handle
295 * @param new_cfg the new configuration to replace the old one
298 GNUNET_TESTBED_host_replace_cfg_ (struct GNUNET_TESTBED_Host *host,
299 const struct GNUNET_CONFIGURATION_Handle *new_cfg)
301 GNUNET_CONFIGURATION_destroy (host->cfg);
302 host->cfg = GNUNET_CONFIGURATION_dup (new_cfg);
307 * Create a host to run peers and controllers on.
309 * @param id global host ID assigned to the host; 0 is
310 * reserved to always mean 'localhost'
311 * @param hostname name of the host, use "NULL" for localhost
312 * @param username username to use for the login; may be NULL
313 * @param cfg the configuration to use as a template while starting a controller
314 * on this host. Operation queue sizes specific to a host are also
315 * read from this configuration handle
316 * @param port port number to use for ssh; use 0 to let ssh decide
317 * @return handle to the host, NULL on error
319 struct GNUNET_TESTBED_Host *
320 GNUNET_TESTBED_host_create_with_id (uint32_t id, const char *hostname,
321 const char *username,
322 const struct GNUNET_CONFIGURATION_Handle
326 struct GNUNET_TESTBED_Host *host;
327 unsigned int new_size;
329 if ((id < host_list_size) && (NULL != host_list[id]))
331 LOG (GNUNET_ERROR_TYPE_WARNING, "Host with id: %u already created\n", id);
334 host = GNUNET_new (struct GNUNET_TESTBED_Host);
335 host->hostname = (NULL != hostname) ? GNUNET_strdup (hostname) : NULL;
336 host->username = (NULL != username) ? GNUNET_strdup (username) : NULL;
338 host->port = (0 == port) ? 22 : port;
339 host->cfg = GNUNET_CONFIGURATION_dup (cfg);
340 host->opq_parallel_overlay_connect_operations =
341 GNUNET_TESTBED_operation_queue_create_ (OPERATION_QUEUE_TYPE_ADAPTIVE,
343 new_size = host_list_size;
344 while (id >= new_size)
345 new_size += HOST_LIST_GROW_STEP;
346 if (new_size != host_list_size)
347 GNUNET_array_grow (host_list, host_list_size, new_size);
348 GNUNET_assert (id < host_list_size);
349 LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding host with id: %u\n", host->id);
350 host_list[id] = host;
356 * Create a host to run peers and controllers on.
358 * @param hostname name of the host, use "NULL" for localhost
359 * @param username username to use for the login; may be NULL
360 * @param cfg the configuration to use as a template while starting a controller
361 * on this host. Operation queue sizes specific to a host are also
362 * read from this configuration handle
363 * @param port port number to use for ssh; use 0 to let ssh decide
364 * @return handle to the host, NULL on error
366 struct GNUNET_TESTBED_Host *
367 GNUNET_TESTBED_host_create (const char *hostname, const char *username,
368 const struct GNUNET_CONFIGURATION_Handle *cfg,
371 static uint32_t uid_generator;
373 if (NULL == hostname)
374 return GNUNET_TESTBED_host_create_with_id (0, hostname, username,
376 return GNUNET_TESTBED_host_create_with_id (++uid_generator, hostname,
377 username, cfg, port);
382 * Load a set of hosts from a configuration file.
384 * @param filename file with the host specification
385 * @param cfg the configuration to use as a template while starting a controller
386 * on any of the loaded hosts. Operation queue sizes specific to a host
387 * are also read from this configuration handle
388 * @param hosts set to the hosts found in the file; caller must free this if
389 * number of hosts returned is greater than 0
390 * @return number of hosts returned in 'hosts', 0 on error
393 GNUNET_TESTBED_hosts_load_from_file (const char *filename,
394 const struct GNUNET_CONFIGURATION_Handle
396 struct GNUNET_TESTBED_Host ***hosts)
398 //struct GNUNET_TESTBED_Host **host_array;
399 struct GNUNET_TESTBED_Host *starting_host;
405 regmatch_t pmatch[6];
412 GNUNET_assert (NULL != filename);
413 if (GNUNET_YES != GNUNET_DISK_file_test (filename))
415 LOG (GNUNET_ERROR_TYPE_WARNING, _("Hosts file %s not found\n"), filename);
419 GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
423 LOG (GNUNET_ERROR_TYPE_WARNING, _("Hosts file %s has no data\n"), filename);
426 data = GNUNET_malloc (fs);
427 if (fs != GNUNET_DISK_fn_read (filename, data, fs))
430 LOG (GNUNET_ERROR_TYPE_WARNING, _("Hosts file %s cannot be read\n"),
436 starting_host = NULL;
438 /* refer RFC 952 and RFC 1123 for valid hostnames */
439 GNUNET_assert (0 == regcomp (&rex,
440 "^(([[:alnum:]]+)@)?" /* username */
441 "([[:alnum:]]+[-[:alnum:]_\\.]+)" /* hostname */
442 "(:([[:digit:]]{1,5}))?", /* port */
443 REG_EXTENDED | REG_ICASE));
444 while (offset < (fs - 1))
447 if (((data[offset] == '\n')) && (buf != &data[offset]))
455 if ((REG_NOMATCH == regexec (&rex, buf, 6, pmatch, 0))
456 || (-1 == pmatch[3].rm_so))
458 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
459 "Error reading line `%s' in hostfile\n", buf);
460 buf = &data[offset + 1];
463 if (-1 != pmatch[2].rm_so)
465 size = pmatch[2].rm_eo - pmatch[2].rm_so;
466 username = GNUNET_malloc (size + 1);
467 username[size] = '\0';
468 GNUNET_assert (NULL != strncpy (username, buf + pmatch[2].rm_so, size));
470 if (-1 != pmatch[5].rm_so)
472 (void) SSCANF (buf + pmatch[5].rm_so, "%5hd", &port);
474 size = pmatch[3].rm_eo - pmatch[3].rm_so;
475 hostname = GNUNET_malloc (size + 1);
476 hostname[size] = '\0';
477 GNUNET_assert (NULL != strncpy (hostname, buf + pmatch[3].rm_so, size));
478 LOG (GNUNET_ERROR_TYPE_DEBUG,
479 "Successfully read host %s, port %d and user %s from file\n",
480 (NULL == hostname) ? "NULL" : hostname,
482 (NULL == username) ? "NULL" : username);
483 /* We store hosts in a static list; hence we only require the starting
484 * host pointer in that list to access the newly created list of hosts */
485 if (NULL == starting_host)
486 starting_host = GNUNET_TESTBED_host_create (hostname, username, cfg,
489 (void) GNUNET_TESTBED_host_create (hostname, username, cfg, port);
491 GNUNET_free_non_null (username);
492 GNUNET_free (hostname);
493 buf = &data[offset + 1];
495 else if ((data[offset] == '\n') || (data[offset] == '\0'))
496 buf = &data[offset + 1];
500 if (NULL == starting_host)
502 *hosts = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Host *) * count);
503 memcpy (*hosts, &host_list[GNUNET_TESTBED_host_get_id_ (starting_host)],
504 sizeof (struct GNUNET_TESTBED_Host *) * count);
510 * Resolves a hostname using getaddrinfo
512 * @param host the hostname
513 * @return the string representing the IPv4 address of the given host; NULL upon error
516 simple_resolve (const char *host)
518 struct addrinfo *res;
519 const struct sockaddr_in *in_addr;
521 struct addrinfo hint;
524 hint.ai_family = AF_INET; /* IPv4 */
525 hint.ai_socktype = 0;
526 hint.ai_protocol = 0;
529 hint.ai_canonname = NULL;
531 hint.ai_flags = AI_NUMERICSERV;
533 LOG_DEBUG ("Resolving [%s]\n", host);
534 if (0 != (rc = getaddrinfo (host, "22", &hint, &res)))
536 LOG_GAI (GNUNET_ERROR_TYPE_ERROR, "getaddrinfo", rc);
539 GNUNET_assert (NULL != res);
540 GNUNET_assert (NULL != res->ai_addr);
541 GNUNET_assert (sizeof (struct sockaddr_in) == res->ai_addrlen);
542 in_addr = (const struct sockaddr_in *) res->ai_addr;
543 hostip = inet_ntoa (in_addr->sin_addr);
544 GNUNET_assert (NULL != hostip);
546 LOG_DEBUG ("Resolved [%s] to [%s]\n", host, hostip);
552 * Loads the set of host allocated by the LoadLeveler Job Scheduler. This
553 * function is only available when compiled with support for LoadLeveler and is
554 * used for running on the SuperMUC
556 * @param cfg the configuration to use as a template while starting a controller
557 * on any of the loaded hosts. Operation queue sizes specific to a host
558 * are also read from this configuration handle
559 * @param hosts set to the hosts found in the file; caller must free this if
560 * number of hosts returned is greater than 0
561 * @return number of hosts returned in 'hosts', 0 on error
564 GNUNET_TESTBED_hosts_load_from_loadleveler (const struct
565 GNUNET_CONFIGURATION_Handle *cfg,
566 struct GNUNET_TESTBED_Host ***hosts)
569 LOG (GNUNET_ERROR_TYPE_ERROR,
570 _("The function %s is only available when compiled with (--with-ll)\n"),
574 const char *hostfile;
576 if (NULL == (hostfile = getenv ("MP_SAVEHOSTFILE")))
581 return GNUNET_TESTBED_hosts_load_from_file (hostfile, cfg, hosts);
587 * Destroy a host handle. Must only be called once everything
588 * running on that host has been stopped.
590 * @param host handle to destroy
593 GNUNET_TESTBED_host_destroy (struct GNUNET_TESTBED_Host *host)
595 struct RegisteredController *rc;
598 GNUNET_assert (host->id < host_list_size);
599 GNUNET_assert (host_list[host->id] == host);
600 host_list[host->id] = NULL;
601 /* clear registered controllers list */
602 for (rc = host->rc_head; NULL != rc; rc = host->rc_head)
604 GNUNET_CONTAINER_DLL_remove (host->rc_head, host->rc_tail, rc);
607 GNUNET_free_non_null ((char *) host->username);
608 GNUNET_free_non_null ((char *) host->hostname);
609 GNUNET_TESTBED_operation_queue_destroy_
610 (host->opq_parallel_overlay_connect_operations);
611 GNUNET_CONFIGURATION_destroy (host->cfg);
613 while (host_list_size >= HOST_LIST_GROW_STEP)
615 for (id = host_list_size - 1; id > host_list_size - HOST_LIST_GROW_STEP;
617 if (NULL != host_list[id])
619 if (id != host_list_size - HOST_LIST_GROW_STEP)
621 if (NULL != host_list[id])
623 host_list_size -= HOST_LIST_GROW_STEP;
626 GNUNET_realloc (host_list,
627 sizeof (struct GNUNET_TESTBED_Host *) * host_list_size);
632 * Marks a host as registered with a controller
634 * @param host the host to mark
635 * @param controller the controller at which this host is registered
638 GNUNET_TESTBED_mark_host_registered_at_ (struct GNUNET_TESTBED_Host *host,
639 const struct GNUNET_TESTBED_Controller
642 struct RegisteredController *rc;
644 for (rc = host->rc_head; NULL != rc; rc = rc->next)
646 if (controller == rc->controller) /* already registered at controller */
652 rc = GNUNET_new (struct RegisteredController);
653 rc->controller = controller;
654 GNUNET_CONTAINER_DLL_insert_tail (host->rc_head, host->rc_tail, rc);
659 * Unmarks a host registered at a controller
661 * @param host the host to unmark
662 * @param controller the controller at which this host has to be unmarked
665 GNUNET_TESTBED_deregister_host_at_ (struct GNUNET_TESTBED_Host *host,
666 const struct GNUNET_TESTBED_Controller
669 struct RegisteredController *rc;
671 for (rc = host->rc_head; NULL != rc; rc=rc->next)
672 if (controller == rc->controller)
679 GNUNET_CONTAINER_DLL_remove (host->rc_head, host->rc_tail, rc);
685 * Checks whether a host has been registered
687 * @param host the host to check
688 * @param controller the controller at which host's registration is checked
689 * @return GNUNET_YES if registered; GNUNET_NO if not
692 GNUNET_TESTBED_is_host_registered_ (const struct GNUNET_TESTBED_Host *host,
693 const struct GNUNET_TESTBED_Controller
696 struct RegisteredController *rc;
698 for (rc = host->rc_head; NULL != rc; rc = rc->next)
700 if (controller == rc->controller) /* already registered at controller */
710 * Handle for controller process
712 struct GNUNET_TESTBED_ControllerProc
717 struct GNUNET_HELPER_Handle *helper;
720 * The arguments used to start the helper
725 * The host where the helper is run
727 struct GNUNET_TESTBED_Host *host;
730 * The controller error callback
732 GNUNET_TESTBED_ControllerStatusCallback cb;
735 * The closure for the above callback
740 * The send handle for the helper
742 struct GNUNET_HELPER_SendHandle *shandle;
745 * The message corresponding to send handle
747 struct GNUNET_MessageHeader *msg;
753 * Function to copy NULL terminated list of arguments
755 * @param argv the NULL terminated list of arguments. Cannot be NULL.
756 * @return the copied NULL terminated arguments
759 copy_argv (const char *const *argv)
764 GNUNET_assert (NULL != argv);
765 for (argp = 0; NULL != argv[argp]; argp++) ;
766 argv_dup = GNUNET_malloc (sizeof (char *) * (argp + 1));
767 for (argp = 0; NULL != argv[argp]; argp++)
768 argv_dup[argp] = GNUNET_strdup (argv[argp]);
774 * Function to join NULL terminated list of arguments
776 * @param argv1 the NULL terminated list of arguments. Cannot be NULL.
777 * @param argv2 the NULL terminated list of arguments. Cannot be NULL.
778 * @return the joined NULL terminated arguments
781 join_argv (const char *const *argv1, const char *const *argv2)
790 for (cnt = 0; NULL != argv1[cnt]; cnt++)
792 argv = GNUNET_strdup (argv1[cnt]);
793 GNUNET_array_append (argvj, carg, argv);
795 for (cnt = 0; NULL != argv2[cnt]; cnt++)
797 argv = GNUNET_strdup (argv2[cnt]);
798 GNUNET_array_append (argvj, carg, argv);
800 GNUNET_array_append (argvj, carg, NULL);
806 * Frees the given NULL terminated arguments
808 * @param argv the NULL terminated list of arguments
811 free_argv (char **argv)
815 for (argp = 0; NULL != argv[argp]; argp++)
816 GNUNET_free (argv[argp]);
822 * Generates arguments for opening a remote shell. Builds up the arguments
823 * from the environment variable GNUNET_TESTBED_RSH_CMD. The variable
824 * should not mention `-p' (port) option and destination address as these will
825 * be set locally in the function from its parameteres. If the environmental
826 * variable is not found then it defaults to `ssh -o BatchMode=yes -o
827 * NoHostAuthenticationForLocalhost=yes -o StrictHostkeyChecking=no -o
828 * PasswordAuthentication=noc'
830 * @param port the destination port number
831 * @param hostname the hostname of the target host
832 * @param username the username to use while connecting to target host
833 * @return NULL terminated list of arguments
836 gen_rsh_args (const char *port, const char *hostname, const char *username)
838 static const char *default_ssh_args[] = {
843 "NoHostAuthenticationForLocalhost=yes",
845 "StrictHostKeyChecking=no",
847 "PasswordAuthentication=no",
860 if (NULL != (ssh_cmd = getenv ("GNUNET_TESTBED_RSH_CMD")))
862 ssh_cmd = GNUNET_strdup (ssh_cmd);
863 ssh_cmd_cp = ssh_cmd;
864 for (size = 0; NULL != (arg = strtok (ssh_cmd, " ")); ssh_cmd = NULL)
865 GNUNET_array_append (ssh_args, size, GNUNET_strdup (arg));
866 GNUNET_free (ssh_cmd_cp);
870 ssh_args = copy_argv (default_ssh_args);
871 size = (sizeof (default_ssh_args)) / (sizeof (const char *));
872 GNUNET_array_grow (ssh_args, size, size - 1);
874 for (cnt = 0; cnt < size; cnt++)
899 ssh_args[cnt] = GNUNET_strdup (new_arg);
901 GNUNET_array_append (ssh_args, size, NULL);
907 * Generates the arguments needed for executing the given binary in a remote
908 * shell. Builds the arguments from the environmental variable
909 * GNUNET_TETSBED_RSH_CMD_SUFFIX. If the environmental variable is not found,
910 * only the given binary name will be present in the returned arguments
912 * @param append_args the arguments to append after generating the suffix
913 * arguments. Can be NULL; if not must be NULL terminated 'char *' array
914 * @return NULL-terminated args
917 gen_rsh_suffix_args (const char * const *append_args)
924 unsigned int append_cnt;
928 if (NULL != (rshell_cmd = getenv ("GNUNET_TESTBED_RSH_CMD_SUFFIX")))
930 rshell_cmd = GNUNET_strdup (rshell_cmd);
931 rshell_cmd_cp = rshell_cmd;
932 for (; NULL != (arg = strtok (rshell_cmd, " ")); rshell_cmd = NULL)
933 GNUNET_array_append (rshell_args, cnt, GNUNET_strdup (arg));
934 GNUNET_free (rshell_cmd_cp);
936 if (NULL != append_args)
938 for (append_cnt = 0; NULL != append_args[append_cnt]; append_cnt++)
939 GNUNET_array_append (rshell_args, cnt, GNUNET_strdup (append_args[append_cnt]));
941 GNUNET_array_append (rshell_args, cnt, NULL);
947 * Functions with this signature are called whenever a
948 * complete message is received by the tokenizer.
950 * Do not call GNUNET_SERVER_mst_destroy in callback
953 * @param client identification of the client
954 * @param message the actual message
956 * @return GNUNET_OK on success, GNUNET_SYSERR to stop further processing
959 helper_mst (void *cls, void *client, const struct GNUNET_MessageHeader *message)
961 struct GNUNET_TESTBED_ControllerProc *cp = cls;
962 const struct GNUNET_TESTBED_HelperReply *msg;
963 const char *hostname;
968 msg = (const struct GNUNET_TESTBED_HelperReply *) message;
969 GNUNET_assert (sizeof (struct GNUNET_TESTBED_HelperReply) <
970 ntohs (msg->header.size));
971 GNUNET_assert (GNUNET_MESSAGE_TYPE_TESTBED_HELPER_REPLY ==
972 ntohs (msg->header.type));
973 config_size = (uLongf) ntohs (msg->config_size);
975 (uLongf) (ntohs (msg->header.size) -
976 sizeof (struct GNUNET_TESTBED_HelperReply));
977 config = GNUNET_malloc (config_size);
978 GNUNET_assert (Z_OK ==
979 uncompress ((Bytef *) config, &config_size,
980 (const Bytef *) &msg[1], xconfig_size));
981 /* Replace the configuration template present in the host with the
982 controller's running configuration */
983 GNUNET_CONFIGURATION_destroy (cp->host->cfg);
984 cp->host->cfg = GNUNET_CONFIGURATION_create ();
985 GNUNET_assert (GNUNET_CONFIGURATION_deserialize
986 (cp->host->cfg, config, config_size, GNUNET_NO));
987 GNUNET_free (config);
988 if (NULL == (hostname = GNUNET_TESTBED_host_get_hostname (cp->host)))
989 hostname = "localhost";
990 /* Change the hostname so that we can connect to it */
991 GNUNET_CONFIGURATION_set_value_string (cp->host->cfg, "testbed", "hostname",
993 cp->host->locked = GNUNET_NO;
994 cp->host->controller_started = GNUNET_YES;
995 cp->cb (cp->cls, cp->host->cfg, GNUNET_OK);
1001 * Continuation function from GNUNET_HELPER_send()
1003 * @param cls closure
1004 * @param result GNUNET_OK on success,
1005 * GNUNET_NO if helper process died
1006 * GNUNET_SYSERR during GNUNET_HELPER_stop
1009 clear_msg (void *cls, int result)
1011 struct GNUNET_TESTBED_ControllerProc *cp = cls;
1013 GNUNET_assert (NULL != cp->shandle);
1015 GNUNET_free (cp->msg);
1021 * Callback that will be called when the helper process dies. This is not called
1022 * when the helper process is stoped using GNUNET_HELPER_stop()
1024 * @param cls the closure from GNUNET_HELPER_start()
1027 helper_exp_cb (void *cls)
1029 struct GNUNET_TESTBED_ControllerProc *cp = cls;
1030 GNUNET_TESTBED_ControllerStatusCallback cb;
1036 GNUNET_TESTBED_controller_stop (cp);
1038 cb (cb_cls, NULL, GNUNET_SYSERR);
1043 * Starts a controller process at the given host. The given host's configration
1044 * is used as a Template configuration to use for the remote controller; the
1045 * remote controller will be started with a slightly modified configuration
1046 * (port numbers, unix domain sockets and service home values are changed as per
1047 * TESTING library on the remote host). The modified configuration replaces the
1048 * host's existing configuration before signalling success through the
1049 * GNUNET_TESTBED_ControllerStatusCallback()
1051 * @param trusted_ip the ip address of the controller which will be set as TRUSTED
1052 * HOST(all connections form this ip are permitted by the testbed) when
1053 * starting testbed controller at host. This can either be a single ip
1054 * address or a network address in CIDR notation.
1055 * @param host the host where the controller has to be started. CANNOT be NULL.
1056 * @param cb function called when the controller is successfully started or
1057 * dies unexpectedly; GNUNET_TESTBED_controller_stop shouldn't be
1058 * called if cb is called with GNUNET_SYSERR as status. Will never be
1059 * called in the same task as 'GNUNET_TESTBED_controller_start'
1060 * (synchronous errors will be signalled by returning NULL). This
1061 * parameter cannot be NULL.
1062 * @param cls closure for above callbacks
1063 * @return the controller process handle, NULL on errors
1065 struct GNUNET_TESTBED_ControllerProc *
1066 GNUNET_TESTBED_controller_start (const char *trusted_ip,
1067 struct GNUNET_TESTBED_Host *host,
1068 GNUNET_TESTBED_ControllerStatusCallback cb,
1071 struct GNUNET_TESTBED_ControllerProc *cp;
1072 struct GNUNET_TESTBED_HelperInit *msg;
1073 const struct GNUNET_CONFIGURATION_Handle *cfg;
1074 const char *hostname;
1075 static char *const binary_argv[] = {
1076 HELPER_TESTBED_BINARY, NULL
1079 GNUNET_assert (NULL != host);
1080 GNUNET_assert (NULL != (cfg = GNUNET_TESTBED_host_get_cfg_ (host)));
1082 API_VIOLATION (GNUNET_NO == host->locked,
1083 "Host is already locked by a previous call to GNUNET_TESTBED_controller_start()");
1084 host->locked = GNUNET_YES;
1085 API_VIOLATION (GNUNET_NO == host->controller_started,
1086 "Attempting to start a controller on a host which is already started a controller");
1087 cp = GNUNET_new (struct GNUNET_TESTBED_ControllerProc);
1088 if (0 == GNUNET_TESTBED_host_get_id_ (host))
1091 GNUNET_HELPER_start (GNUNET_YES, HELPER_TESTBED_BINARY, binary_argv,
1092 &helper_mst, &helper_exp_cb, cp);
1096 char *helper_binary_path_args[2];
1098 char **rsh_suffix_args;
1099 const char *username;
1105 username = host->username;
1106 hostname = host->hostname;
1107 GNUNET_asprintf (&port, "%u", host->port);
1108 LOG_DEBUG ("Starting remote connection to destination %s\n", hostname);
1110 GNUNET_CONFIGURATION_get_value_filename (cfg, "testbed",
1111 "HELPER_BINARY_PATH",
1112 &helper_binary_path_args[0]))
1113 helper_binary_path_args[0] =
1114 GNUNET_OS_get_libexec_binary_path (HELPER_TESTBED_BINARY);
1115 helper_binary_path_args[1] = NULL;
1116 rsh_args = gen_rsh_args (port, hostname, username);
1117 rsh_suffix_args = gen_rsh_suffix_args ((const char **) helper_binary_path_args);
1119 join_argv ((const char **) rsh_args, (const char **) rsh_suffix_args);
1120 free_argv (rsh_args);
1121 free_argv (rsh_suffix_args);
1123 argstr = GNUNET_strdup ("");
1124 for (cnt = 0; NULL != cp->helper_argv[cnt]; cnt++)
1127 GNUNET_assert (0 < GNUNET_asprintf (&argstr, "%s %s", aux, cp->helper_argv[cnt]));
1130 LOG_DEBUG ("Helper cmd str: %s\n", argstr);
1131 GNUNET_free (argstr);
1133 GNUNET_HELPER_start (GNUNET_NO, cp->helper_argv[0], cp->helper_argv, &helper_mst,
1134 &helper_exp_cb, cp);
1135 GNUNET_free (helper_binary_path_args[0]);
1137 if (NULL == cp->helper)
1139 if (NULL != cp->helper_argv)
1140 free_argv (cp->helper_argv);
1147 msg = GNUNET_TESTBED_create_helper_init_msg_ (trusted_ip, hostname, cfg);
1148 cp->msg = &msg->header;
1150 GNUNET_HELPER_send (cp->helper, &msg->header, GNUNET_NO, &clear_msg, cp);
1151 if (NULL == cp->shandle)
1154 GNUNET_TESTBED_controller_stop (cp);
1162 * Sends termination signal to the controller's helper process
1164 * @param cproc the handle to the controller's helper process
1167 GNUNET_TESTBED_controller_kill_ (struct GNUNET_TESTBED_ControllerProc *cproc)
1169 if (NULL != cproc->shandle)
1170 GNUNET_HELPER_send_cancel (cproc->shandle);
1171 if (NULL != cproc->helper)
1172 GNUNET_HELPER_kill (cproc->helper, GNUNET_YES);
1177 * Cleans-up the controller's helper process handle
1179 * @param cproc the handle to the controller's helper process
1182 GNUNET_TESTBED_controller_destroy_ (struct GNUNET_TESTBED_ControllerProc *cproc)
1184 if (NULL != cproc->helper)
1186 GNUNET_break (GNUNET_OK == GNUNET_HELPER_wait (cproc->helper));
1187 GNUNET_HELPER_destroy (cproc->helper);
1189 if (NULL != cproc->helper_argv)
1190 free_argv (cproc->helper_argv);
1191 cproc->host->controller_started = GNUNET_NO;
1192 cproc->host->locked = GNUNET_NO;
1193 GNUNET_free_non_null (cproc->msg);
1194 GNUNET_free (cproc);
1199 * Stop the controller process (also will terminate all peers and controllers
1200 * dependent on this controller). This function blocks until the testbed has
1201 * been fully terminated (!). The controller status cb from
1202 * GNUNET_TESTBED_controller_start() will not be called.
1204 * @param cproc the controller process handle
1207 GNUNET_TESTBED_controller_stop (struct GNUNET_TESTBED_ControllerProc *cproc)
1209 GNUNET_TESTBED_controller_kill_ (cproc);
1210 GNUNET_TESTBED_controller_destroy_ (cproc);
1215 * The handle for whether a host is habitable or not
1217 struct GNUNET_TESTBED_HostHabitableCheckHandle
1222 const struct GNUNET_TESTBED_Host *host;
1225 * The callback to call once we have the status
1227 GNUNET_TESTBED_HostHabitableCallback cb;
1230 * The callback closure
1235 * The process handle for the SSH process
1237 struct GNUNET_OS_Process *auxp;
1240 * The arguments used to start the helper
1245 * Task id for the habitability check task
1247 struct GNUNET_SCHEDULER_Task * habitability_check_task;
1250 * How long we wait before checking the process status. Should grow
1253 struct GNUNET_TIME_Relative wait_time;
1259 * Task for checking whether a host is habitable or not
1261 * @param cls GNUNET_TESTBED_HostHabitableCheckHandle
1264 habitability_check (void *cls)
1266 struct GNUNET_TESTBED_HostHabitableCheckHandle *h = cls;
1268 GNUNET_TESTBED_HostHabitableCallback cb;
1269 const struct GNUNET_TESTBED_Host *host;
1271 enum GNUNET_OS_ProcessStatusType type;
1274 h->habitability_check_task = NULL;
1275 ret = GNUNET_OS_process_status (h->auxp, &type, &code);
1276 if (GNUNET_SYSERR == ret)
1282 if (GNUNET_NO == ret)
1284 h->wait_time = GNUNET_TIME_STD_BACKOFF (h->wait_time);
1285 h->habitability_check_task =
1286 GNUNET_SCHEDULER_add_delayed (h->wait_time, &habitability_check, h);
1289 GNUNET_OS_process_destroy (h->auxp);
1291 ret = (0 != code) ? GNUNET_NO : GNUNET_YES;
1294 if (NULL != h->auxp)
1295 GNUNET_OS_process_destroy (h->auxp);
1299 free_argv (h->helper_argv);
1302 cb (cb_cls, host, ret);
1307 * Checks whether a host can be used to start testbed service
1309 * @param host the host to check
1310 * @param config the configuration handle to lookup the path of the testbed
1312 * @param cb the callback to call to inform about habitability of the given host
1313 * @param cb_cls the closure for the callback
1314 * @return NULL upon any error or a handle which can be passed to
1315 * GNUNET_TESTBED_is_host_habitable_cancel()
1317 struct GNUNET_TESTBED_HostHabitableCheckHandle *
1318 GNUNET_TESTBED_is_host_habitable (const struct GNUNET_TESTBED_Host *host,
1319 const struct GNUNET_CONFIGURATION_Handle
1321 GNUNET_TESTBED_HostHabitableCallback cb,
1324 struct GNUNET_TESTBED_HostHabitableCheckHandle *h;
1326 char **rsh_suffix_args;
1328 const char *hostname;
1331 h = GNUNET_new (struct GNUNET_TESTBED_HostHabitableCheckHandle);
1335 hostname = (NULL == host->hostname) ? "127.0.0.1" : host->hostname;
1337 GNUNET_CONFIGURATION_get_value_filename (config, "testbed",
1338 "HELPER_BINARY_PATH",
1341 GNUNET_OS_get_libexec_binary_path (HELPER_TESTBED_BINARY);
1342 GNUNET_asprintf (&port, "%u", host->port);
1343 rsh_args = gen_rsh_args (port, hostname, host->username);
1346 stat_args[0] = "stat";
1347 stat_args[2] = NULL;
1348 rsh_suffix_args = gen_rsh_suffix_args ((const char **) stat_args);
1349 GNUNET_free (stat_args[1]);
1350 h->helper_argv = join_argv ((const char **) rsh_args,
1351 (const char **) rsh_suffix_args);
1352 free_argv (rsh_suffix_args);
1353 free_argv (rsh_args);
1355 GNUNET_OS_start_process_vap (GNUNET_NO, GNUNET_OS_INHERIT_STD_ERR, NULL,
1356 NULL, NULL, h->helper_argv[0], h->helper_argv);
1357 if (NULL == h->auxp)
1359 GNUNET_break (0); /* Cannot exec SSH? */
1363 h->wait_time = GNUNET_TIME_STD_BACKOFF (h->wait_time);
1364 h->habitability_check_task =
1365 GNUNET_SCHEDULER_add_delayed (h->wait_time, &habitability_check, h);
1371 * Function to cancel a request started using GNUNET_TESTBED_is_host_habitable()
1373 * @param handle the habitability check handle
1376 GNUNET_TESTBED_is_host_habitable_cancel (struct
1377 GNUNET_TESTBED_HostHabitableCheckHandle
1380 GNUNET_SCHEDULER_cancel (handle->habitability_check_task);
1381 (void) GNUNET_OS_process_kill (handle->auxp, GNUNET_TERM_SIG);
1382 (void) GNUNET_OS_process_wait (handle->auxp);
1383 GNUNET_OS_process_destroy (handle->auxp);
1384 free_argv (handle->helper_argv);
1385 GNUNET_free (handle);
1390 * handle for host registration
1392 struct GNUNET_TESTBED_HostRegistrationHandle
1395 * The host being registered
1397 struct GNUNET_TESTBED_Host *host;
1400 * The controller at which this host is being registered
1402 struct GNUNET_TESTBED_Controller *c;
1405 * The Registartion completion callback
1407 GNUNET_TESTBED_HostRegistrationCompletion cc;
1410 * The closure for above callback
1417 * Register a host with the controller
1419 * @param controller the controller handle
1420 * @param host the host to register
1421 * @param cc the completion callback to call to inform the status of
1422 * registration. After calling this callback the registration handle
1423 * will be invalid. Cannot be NULL.
1424 * @param cc_cls the closure for the cc
1425 * @return handle to the host registration which can be used to cancel the
1428 struct GNUNET_TESTBED_HostRegistrationHandle *
1429 GNUNET_TESTBED_register_host (struct GNUNET_TESTBED_Controller *controller,
1430 struct GNUNET_TESTBED_Host *host,
1431 GNUNET_TESTBED_HostRegistrationCompletion cc,
1434 struct GNUNET_TESTBED_HostRegistrationHandle *rh;
1435 struct GNUNET_TESTBED_AddHostMessage *msg;
1436 const char *username;
1437 const char *hostname;
1444 uint16_t username_length;
1445 uint16_t hostname_length;
1447 if (NULL != controller->rh)
1449 hostname = GNUNET_TESTBED_host_get_hostname (host);
1450 if (GNUNET_YES == GNUNET_TESTBED_is_host_registered_ (host, controller))
1452 LOG (GNUNET_ERROR_TYPE_WARNING, "Host hostname: %s already registered\n",
1453 (NULL == hostname) ? "localhost" : hostname);
1456 rh = GNUNET_new (struct GNUNET_TESTBED_HostRegistrationHandle);
1459 GNUNET_assert (NULL != cc);
1461 rh->cc_cls = cc_cls;
1462 controller->rh = rh;
1463 username = GNUNET_TESTBED_host_get_username_ (host);
1464 username_length = 0;
1465 if (NULL != username)
1466 username_length = strlen (username);
1467 GNUNET_assert (NULL != hostname); /* Hostname must be present */
1468 hostname_length = strlen (hostname);
1469 GNUNET_assert (NULL != host->cfg);
1470 config = GNUNET_CONFIGURATION_serialize (host->cfg, &config_size);
1471 cc_size = GNUNET_TESTBED_compress_config_ (config, config_size, &cconfig);
1472 GNUNET_free (config);
1473 msg_size = (sizeof (struct GNUNET_TESTBED_AddHostMessage));
1474 msg_size += username_length;
1475 msg_size += hostname_length;
1476 msg_size += cc_size;
1477 msg = GNUNET_malloc (msg_size);
1478 msg->header.size = htons (msg_size);
1479 msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST);
1480 msg->host_id = htonl (GNUNET_TESTBED_host_get_id_ (host));
1481 msg->ssh_port = htons (GNUNET_TESTBED_host_get_ssh_port_ (host));
1483 if (NULL != username)
1485 msg->username_length = htons (username_length);
1486 ptr = memcpy (ptr, username, username_length);
1487 ptr += username_length;
1489 msg->hostname_length = htons (hostname_length);
1490 ptr = memcpy (ptr, hostname, hostname_length);
1491 ptr += hostname_length;
1492 msg->config_size = htons (config_size);
1493 ptr = memcpy (ptr, cconfig, cc_size);
1495 GNUNET_assert ((ptr - (void *) msg) == msg_size);
1496 GNUNET_free (cconfig);
1497 GNUNET_TESTBED_queue_message_ (controller,
1498 (struct GNUNET_MessageHeader *) msg);
1504 * Cancel the pending registration. Note that if the registration message is
1505 * already sent to the service the cancellation has only the effect that the
1506 * registration completion callback for the registration is never called.
1508 * @param handle the registration handle to cancel
1511 GNUNET_TESTBED_cancel_registration (struct GNUNET_TESTBED_HostRegistrationHandle
1514 if (handle != handle->c->rh)
1519 handle->c->rh = NULL;
1520 GNUNET_free (handle);
1525 * Queues the given operation in the queue for parallel overlay connects of the
1528 * @param h the host handle
1529 * @param op the operation to queue in the given host's parally overlay connect
1533 GNUNET_TESTBED_host_queue_oc_ (struct GNUNET_TESTBED_Host *h,
1534 struct GNUNET_TESTBED_Operation *op)
1536 GNUNET_TESTBED_operation_queue_insert_
1537 (h->opq_parallel_overlay_connect_operations, op);
1542 * Handler for GNUNET_MESSAGE_TYPE_TESTBED_ADDHOSTCONFIRM message from
1543 * controller (testbed service)
1545 * @param c the controller handler
1546 * @param msg message received
1547 * @return GNUNET_YES if we can continue receiving from service; GNUNET_NO if
1551 GNUNET_TESTBED_host_handle_addhostconfirm_ (struct GNUNET_TESTBED_Controller *c,
1553 GNUNET_TESTBED_HostConfirmedMessage
1556 struct GNUNET_TESTBED_HostRegistrationHandle *rh;
1565 if (GNUNET_TESTBED_host_get_id_ (rh->host) != ntohl (msg->host_id))
1567 LOG_DEBUG ("Mismatch in host id's %u, %u of host confirm msg\n",
1568 GNUNET_TESTBED_host_get_id_ (rh->host), ntohl (msg->host_id));
1572 msg_size = ntohs (msg->header.size);
1573 if (sizeof (struct GNUNET_TESTBED_HostConfirmedMessage) == msg_size)
1575 LOG_DEBUG ("Host %u successfully registered\n", ntohl (msg->host_id));
1576 GNUNET_TESTBED_mark_host_registered_at_ (rh->host, c);
1577 rh->cc (rh->cc_cls, NULL);
1581 /* We have an error message */
1582 emsg = (char *) &msg[1];
1584 emsg[msg_size - sizeof (struct GNUNET_TESTBED_HostConfirmedMessage)])
1590 LOG (GNUNET_ERROR_TYPE_ERROR, _("Adding host %u failed with error: %s\n"),
1591 ntohl (msg->host_id), emsg);
1592 rh->cc (rh->cc_cls, emsg);
1599 * Resolves the hostname of the host to an ip address
1601 * @param host the host whose hostname is to be resolved
1604 GNUNET_TESTBED_host_resolve_ (struct GNUNET_TESTBED_Host *host)
1608 hostname = (char *) host->hostname;
1609 host->hostname = simple_resolve (hostname);
1610 if (NULL == host->hostname)
1613 host->hostname = hostname;
1616 GNUNET_free (hostname);
1617 host->hostname = GNUNET_strdup (host->hostname);
1620 /* end of testbed_api_hosts.c */