src/testbed/testbed_api_hosts.c

   1 /*
   2       This file is part of GNUnet
   3       Copyright (C) 2008--2013 GNUnet e.V.
   4
   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.
   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       General Public License for more details.
  14
  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.
  19  */
  20
  21 /**
  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
  27  */
  28 #include "platform.h"
  29 #include "gnunet_util_lib.h"
  30 #include "gnunet_testbed_service.h"
  31 #include "gnunet_core_service.h"
  32 #include "gnunet_transport_service.h"
  33
  34 #include "testbed_api.h"
  35 #include "testbed_api_hosts.h"
  36 #include "testbed_helper.h"
  37 #include "testbed_api_operations.h"
  38
  39 #include <zlib.h>
  40 #include <regex.h>
  41
  42 /**
  43  * Generic logging shorthand
  44  */
  45 #define LOG(kind, ...)                          \
  46   GNUNET_log_from (kind, "testbed-api-hosts", __VA_ARGS__);
  47
  48 /**
  49  * Debug logging shorthand
  50  */
  51 #define LOG_DEBUG(...)                          \
  52   LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__);
  53
  54 /**
  55  * Prints API violation message
  56  */
  57 #define API_VIOLATION(cond,errstr)              \
  58   do {                                          \
  59     if (cond)                                   \
  60       break;                                    \
  61     LOG (GNUNET_ERROR_TYPE_ERROR, "API violation detected: %s\n", errstr); \
  62     GNUNET_assert (0);                                                  \
  63   } while (0)
  64
  65 /**
  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).
  68  */
  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)
  70
  71 /**
  72  * Number of extra elements we create space for when we grow host list
  73  */
  74 #define HOST_LIST_GROW_STEP 10
  75
  76
  77 /**
  78  * A list entry for registered controllers list
  79  */
  80 struct RegisteredController
  81 {
  82   /**
  83    * The controller at which this host is registered
  84    */
  85   const struct GNUNET_TESTBED_Controller *controller;
  86
  87   /**
  88    * The next ptr for DLL
  89    */
  90   struct RegisteredController *next;
  91
  92   /**
  93    * The prev ptr for DLL
  94    */
  95   struct RegisteredController *prev;
  96 };
  97
  98
  99 /**
 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
 102  * ssh-agent).
 103  */
 104 struct GNUNET_TESTBED_Host
 105 {
 106
 107   /**
 108    * The hostname of the host; NULL for localhost
 109    */
 110   const char *hostname;
 111
 112   /**
 113    * The username to be used for SSH login
 114    */
 115   const char *username;
 116
 117   /**
 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
 122    */
 123   struct GNUNET_CONFIGURATION_Handle *cfg;
 124
 125   /**
 126    * The head for the list of controllers where this host is registered
 127    */
 128   struct RegisteredController *rc_head;
 129
 130   /**
 131    * The tail for the list of controllers where this host is registered
 132    */
 133   struct RegisteredController *rc_tail;
 134
 135   /**
 136    * Operation queue for simultaneous overlay connect operations target at this
 137    * host
 138    */
 139   struct OperationQueue *opq_parallel_overlay_connect_operations;
 140
 141   /**
 142    * Is a controller started on this host? FIXME: Is this needed?
 143    */
 144   int controller_started;
 145
 146   /**
 147    * Is this host locked by GNUNET_TESTBED_controller_start()?
 148    */
 149   int locked;
 150
 151   /**
 152    * Global ID we use to refer to a host on the network
 153    */
 154   uint32_t id;
 155
 156   /**
 157    * The port which is to be used for SSH
 158    */
 159   uint16_t port;
 160
 161 };
 162
 163
 164 /**
 165  * Array of available hosts
 166  */
 167 static struct GNUNET_TESTBED_Host **host_list;
 168
 169 /**
 170  * The size of the available hosts list
 171  */
 172 static unsigned int host_list_size;
 173
 174
 175 /**
 176  * Lookup a host by ID.
 177  *
 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
 181  */
 182 struct GNUNET_TESTBED_Host *
 183 GNUNET_TESTBED_host_lookup_by_id_ (uint32_t id)
 184 {
 185   if (host_list_size <= id)
 186     return NULL;
 187   return host_list[id];
 188 }
 189
 190
 191 /**
 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
 194  * internally.
 195  *
 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
 202  */
 203 struct GNUNET_TESTBED_Host *
 204 GNUNET_TESTBED_host_create_by_id_ (uint32_t id,
 205                                    const struct GNUNET_CONFIGURATION_Handle *cfg)
 206 {
 207   return GNUNET_TESTBED_host_create_with_id (id, NULL, NULL, cfg, 0);
 208 }
 209
 210
 211 /**
 212  * Obtain the host's unique global ID.
 213  *
 214  * @param host handle to the host, NULL means 'localhost'
 215  * @return id global host ID assigned to the host (0 is
 216  *         'localhost', but then obviously not globally unique)
 217  */
 218 uint32_t
 219 GNUNET_TESTBED_host_get_id_ (const struct GNUNET_TESTBED_Host * host)
 220 {
 221   return host->id;
 222 }
 223
 224
 225 /**
 226  * Obtain the host's hostname.
 227  *
 228  * @param host handle to the host, NULL means 'localhost'
 229  * @return hostname of the host
 230  */
 231 const char *
 232 GNUNET_TESTBED_host_get_hostname (const struct GNUNET_TESTBED_Host *host)
 233 {
 234   return host->hostname;
 235 }
 236
 237
 238 /**
 239  * Obtain the host's username
 240  *
 241  * @param host handle to the host, NULL means 'localhost'
 242  * @return username to login to the host
 243  */
 244 const char *
 245 GNUNET_TESTBED_host_get_username_ (const struct GNUNET_TESTBED_Host *host)
 246 {
 247   return host->username;
 248 }
 249
 250
 251 /**
 252  * Obtain the host's ssh port
 253  *
 254  * @param host handle to the host, NULL means 'localhost'
 255  * @return username to login to the host
 256  */
 257 uint16_t
 258 GNUNET_TESTBED_host_get_ssh_port_ (const struct GNUNET_TESTBED_Host * host)
 259 {
 260   return host->port;
 261 }
 262
 263
 264 /**
 265  * Check whether a controller is already started on the given host
 266  *
 267  * @param host the handle to the host
 268  * @return GNUNET_YES if the controller is already started; GNUNET_NO if not
 269  */
 270 int
 271 GNUNET_TESTBED_host_controller_started (const struct GNUNET_TESTBED_Host *host)
 272 {
 273   return host->controller_started;
 274 }
 275
 276
 277 /**
 278  * Obtain the host's configuration template
 279  *
 280  * @param host handle to the host
 281  * @return the host's configuration template
 282  */
 283 const struct GNUNET_CONFIGURATION_Handle *
 284 GNUNET_TESTBED_host_get_cfg_ (const struct GNUNET_TESTBED_Host *host)
 285 {
 286   return host->cfg;
 287 }
 288
 289
 290 /**
 291  * Function to replace host's configuration
 292  *
 293  * @param host the host handle
 294  * @param new_cfg the new configuration to replace the old one
 295  */
 296 void
 297 GNUNET_TESTBED_host_replace_cfg_ (struct GNUNET_TESTBED_Host *host,
 298                                   const struct GNUNET_CONFIGURATION_Handle *new_cfg)
 299 {
 300   GNUNET_CONFIGURATION_destroy (host->cfg);
 301   host->cfg = GNUNET_CONFIGURATION_dup (new_cfg);
 302 }
 303
 304
 305 /**
 306  * Create a host to run peers and controllers on.
 307  *
 308  * @param id global host ID assigned to the host; 0 is
 309  *        reserved to always mean 'localhost'
 310  * @param hostname name of the host, use "NULL" for localhost
 311  * @param username username to use for the login; may be NULL
 312  * @param cfg the configuration to use as a template while starting a controller
 313  *          on this host.  Operation queue sizes specific to a host are also
 314  *          read from this configuration handle
 315  * @param port port number to use for ssh; use 0 to let ssh decide
 316  * @return handle to the host, NULL on error
 317  */
 318 struct GNUNET_TESTBED_Host *
 319 GNUNET_TESTBED_host_create_with_id (uint32_t id, const char *hostname,
 320                                     const char *username,
 321                                     const struct GNUNET_CONFIGURATION_Handle
 322                                     *cfg,
 323                                     uint16_t port)
 324 {
 325   struct GNUNET_TESTBED_Host *host;
 326   unsigned int new_size;
 327
 328   if ((id < host_list_size) && (NULL != host_list[id]))
 329   {
 330     LOG (GNUNET_ERROR_TYPE_WARNING, "Host with id: %u already created\n", id);
 331     return NULL;
 332   }
 333   host = GNUNET_new (struct GNUNET_TESTBED_Host);
 334   host->hostname = (NULL != hostname) ? GNUNET_strdup (hostname) : NULL;
 335   host->username = (NULL != username) ? GNUNET_strdup (username) : NULL;
 336   host->id = id;
 337   host->port = (0 == port) ? 22 : port;
 338   host->cfg = GNUNET_CONFIGURATION_dup (cfg);
 339   host->opq_parallel_overlay_connect_operations =
 340       GNUNET_TESTBED_operation_queue_create_ (OPERATION_QUEUE_TYPE_ADAPTIVE,
 341                                               UINT_MAX);
 342   new_size = host_list_size;
 343   while (id >= new_size)
 344     new_size += HOST_LIST_GROW_STEP;
 345   if (new_size != host_list_size)
 346     GNUNET_array_grow (host_list, host_list_size, new_size);
 347   GNUNET_assert (id < host_list_size);
 348   LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding host with id: %u\n", host->id);
 349   host_list[id] = host;
 350   return host;
 351 }
 352
 353
 354 /**
 355  * Create a host to run peers and controllers on.
 356  *
 357  * @param hostname name of the host, use "NULL" for localhost
 358  * @param username username to use for the login; may be NULL
 359  * @param cfg the configuration to use as a template while starting a controller
 360  *          on this host.  Operation queue sizes specific to a host are also
 361  *          read from this configuration handle
 362  * @param port port number to use for ssh; use 0 to let ssh decide
 363  * @return handle to the host, NULL on error
 364  */
 365 struct GNUNET_TESTBED_Host *
 366 GNUNET_TESTBED_host_create (const char *hostname, const char *username,
 367                             const struct GNUNET_CONFIGURATION_Handle *cfg,
 368                             uint16_t port)
 369 {
 370   static uint32_t uid_generator;
 371
 372   if (NULL == hostname)
 373     return GNUNET_TESTBED_host_create_with_id (0, hostname, username,
 374                                                cfg, port);
 375   return GNUNET_TESTBED_host_create_with_id (++uid_generator, hostname,
 376                                              username, cfg, port);
 377 }
 378
 379
 380 /**
 381  * Load a set of hosts from a configuration file.
 382  *
 383  * @param filename file with the host specification
 384  * @param cfg the configuration to use as a template while starting a controller
 385  *          on any of the loaded hosts.  Operation queue sizes specific to a host
 386  *          are also read from this configuration handle
 387  * @param hosts set to the hosts found in the file; caller must free this if
 388  *          number of hosts returned is greater than 0
 389  * @return number of hosts returned in 'hosts', 0 on error
 390  */
 391 unsigned int
 392 GNUNET_TESTBED_hosts_load_from_file (const char *filename,
 393                                      const struct GNUNET_CONFIGURATION_Handle
 394                                      *cfg,
 395                                      struct GNUNET_TESTBED_Host ***hosts)
 396 {
 397   struct GNUNET_TESTBED_Host *starting_host;
 398   char *data;
 399   char *buf;
 400   char *username;
 401   char *hostname;
 402   regex_t rex;
 403   regmatch_t pmatch[6];
 404   uint64_t fs;
 405   short int port;
 406   unsigned int offset;
 407   unsigned int count;
 408
 409
 410   GNUNET_assert (NULL != filename);
 411   if (GNUNET_YES != GNUNET_DISK_file_test (filename))
 412   {
 413     LOG (GNUNET_ERROR_TYPE_WARNING, _("Hosts file %s not found\n"), filename);
 414     return 0;
 415   }
 416   if (GNUNET_OK !=
 417       GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
 418     fs = 0;
 419   if (0 == fs)
 420   {
 421     LOG (GNUNET_ERROR_TYPE_WARNING, _("Hosts file %s has no data\n"), filename);
 422     return 0;
 423   }
 424   data = GNUNET_malloc (fs);
 425   if (fs != GNUNET_DISK_fn_read (filename, data, fs))
 426   {
 427     GNUNET_free (data);
 428     LOG (GNUNET_ERROR_TYPE_WARNING, _("Hosts file %s cannot be read\n"),
 429          filename);
 430     return 0;
 431   }
 432   buf = data;
 433   offset = 0;
 434   starting_host = NULL;
 435   count = 0;
 436   /* refer RFC 952 and RFC 1123 for valid hostnames */
 437   GNUNET_assert (0 == regcomp (&rex,
 438                                "^(([[:alnum:]]+)@)?" /* username */
 439                                "([[:alnum:]]+[-[:alnum:]_\\.]+)" /* hostname */
 440                                "(:([[:digit:]]{1,5}))?", /* port */
 441                                REG_EXTENDED | REG_ICASE));
 442   while (offset < (fs - 1))
 443   {
 444     offset++;
 445     if (((data[offset] == '\n')) && (buf != &data[offset]))
 446     {
 447       unsigned int size;
 448
 449       data[offset] = '\0';
 450       username = NULL;
 451       hostname = NULL;
 452       port = 0;
 453       if ((REG_NOMATCH == regexec (&rex, buf, 6, pmatch, 0))
 454           || (-1 == pmatch[3].rm_so))
 455       {
 456         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 457                     "Error reading line `%s' in hostfile\n", buf);
 458         buf = &data[offset + 1];
 459         continue;
 460       }
 461       if (-1 != pmatch[2].rm_so)
 462       {
 463         size = pmatch[2].rm_eo - pmatch[2].rm_so;
 464         username = GNUNET_malloc (size + 1);
 465         username[size] = '\0';
 466         GNUNET_assert (NULL != strncpy (username, buf + pmatch[2].rm_so, size));
 467       }
 468       if (-1 != pmatch[5].rm_so)
 469       {
 470         (void) SSCANF (buf + pmatch[5].rm_so, "%5hd", &port);
 471       }
 472       size = pmatch[3].rm_eo - pmatch[3].rm_so;
 473       hostname = GNUNET_malloc (size + 1);
 474       hostname[size] = '\0';
 475       GNUNET_assert (NULL != strncpy (hostname, buf + pmatch[3].rm_so, size));
 476       LOG (GNUNET_ERROR_TYPE_DEBUG,
 477            "Successfully read host %s, port %d and user %s from file\n",
 478            (NULL == hostname) ? "NULL" : hostname,
 479            port,
 480            (NULL == username) ? "NULL" : username);
 481       /* We store hosts in a static list; hence we only require the starting
 482        * host pointer in that list to access the newly created list of hosts */
 483       if (NULL == starting_host)
 484         starting_host = GNUNET_TESTBED_host_create (hostname, username, cfg,
 485                                                     port);
 486       else
 487         (void) GNUNET_TESTBED_host_create (hostname, username, cfg, port);
 488       count++;
 489       GNUNET_free_non_null (username);
 490       GNUNET_free (hostname);
 491       buf = &data[offset + 1];
 492     }
 493     else if ((data[offset] == '\n') || (data[offset] == '\0'))
 494       buf = &data[offset + 1];
 495   }
 496   regfree (&rex);
 497   GNUNET_free (data);
 498   if (NULL == starting_host)
 499     return 0;
 500   *hosts = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Host *) * count);
 501   GNUNET_memcpy (*hosts,
 502                  &host_list[GNUNET_TESTBED_host_get_id_ (starting_host)],
 503                  sizeof (struct GNUNET_TESTBED_Host *) * count);
 504   return count;
 505 }
 506
 507
 508 /**
 509  * Resolves a hostname using getaddrinfo
 510  *
 511  * @param host the hostname
 512  * @return the string representing the IPv4 address of the given host; NULL upon error
 513  */
 514 const char *
 515 simple_resolve (const char *host)
 516 {
 517   struct addrinfo *res;
 518   const struct sockaddr_in *in_addr;
 519   char *hostip;
 520   struct addrinfo hint;
 521   unsigned int rc;
 522
 523   hint.ai_family = AF_INET;     /* IPv4 */
 524   hint.ai_socktype = 0;
 525   hint.ai_protocol = 0;
 526   hint.ai_addrlen = 0;
 527   hint.ai_addr = NULL;
 528   hint.ai_canonname = NULL;
 529   hint.ai_next = NULL;
 530   hint.ai_flags = AI_NUMERICSERV;
 531   res = NULL;
 532   LOG_DEBUG ("Resolving [%s]\n", host);
 533   if (0 != (rc = getaddrinfo (host, "22", &hint, &res)))
 534   {
 535     LOG_GAI (GNUNET_ERROR_TYPE_ERROR, "getaddrinfo", rc);
 536     return NULL;
 537   }
 538   GNUNET_assert (NULL != res);
 539   GNUNET_assert (NULL != res->ai_addr);
 540   GNUNET_assert (sizeof (struct sockaddr_in) == res->ai_addrlen);
 541   in_addr = (const struct sockaddr_in *) res->ai_addr;
 542   hostip = inet_ntoa (in_addr->sin_addr);
 543   GNUNET_assert (NULL != hostip);
 544   freeaddrinfo (res);
 545   LOG_DEBUG ("Resolved [%s] to [%s]\n", host, hostip);
 546   return hostip;
 547 }
 548
 549
 550 /**
 551  * Loads the set of host allocated by the LoadLeveler Job Scheduler.  This
 552  * function is only available when compiled with support for LoadLeveler and is
 553  * used for running on the SuperMUC
 554  *
 555  * @param cfg the configuration to use as a template while starting a controller
 556  *          on any of the loaded hosts.  Operation queue sizes specific to a host
 557  *          are also read from this configuration handle
 558  * @param hosts set to the hosts found in the file; caller must free this if
 559  *          number of hosts returned is greater than 0
 560  * @return number of hosts returned in 'hosts', 0 on error
 561  */
 562 unsigned int
 563 GNUNET_TESTBED_hosts_load_from_loadleveler (const struct
 564                                             GNUNET_CONFIGURATION_Handle *cfg,
 565                                             struct GNUNET_TESTBED_Host ***hosts)
 566 {
 567 #if !ENABLE_SUPERMUC
 568   LOG (GNUNET_ERROR_TYPE_ERROR,
 569        _("The function %s is only available when compiled with (--with-ll)\n"),
 570        __func__);
 571   GNUNET_assert (0);
 572 #else
 573   const char *hostfile;
 574
 575   if (NULL == (hostfile = getenv ("MP_SAVEHOSTFILE")))
 576   {
 577     GNUNET_break (0);
 578     return 0;
 579   }
 580   return GNUNET_TESTBED_hosts_load_from_file (hostfile, cfg, hosts);
 581 #endif
 582 }
 583
 584
 585 /**
 586  * Destroy a host handle.  Must only be called once everything
 587  * running on that host has been stopped.
 588  *
 589  * @param host handle to destroy
 590  */
 591 void
 592 GNUNET_TESTBED_host_destroy (struct GNUNET_TESTBED_Host *host)
 593 {
 594   struct RegisteredController *rc;
 595   uint32_t id;
 596
 597   GNUNET_assert (host->id < host_list_size);
 598   GNUNET_assert (host_list[host->id] == host);
 599   host_list[host->id] = NULL;
 600   /* clear registered controllers list */
 601   for (rc = host->rc_head; NULL != rc; rc = host->rc_head)
 602   {
 603     GNUNET_CONTAINER_DLL_remove (host->rc_head, host->rc_tail, rc);
 604     GNUNET_free (rc);
 605   }
 606   GNUNET_free_non_null ((char *) host->username);
 607   GNUNET_free_non_null ((char *) host->hostname);
 608   GNUNET_TESTBED_operation_queue_destroy_
 609       (host->opq_parallel_overlay_connect_operations);
 610   GNUNET_CONFIGURATION_destroy (host->cfg);
 611   GNUNET_free (host);
 612   while (host_list_size >= HOST_LIST_GROW_STEP)
 613   {
 614     for (id = host_list_size - 1; id > host_list_size - HOST_LIST_GROW_STEP;
 615          id--)
 616       if (NULL != host_list[id])
 617         break;
 618     if (id != host_list_size - HOST_LIST_GROW_STEP)
 619       break;
 620     if (NULL != host_list[id])
 621       break;
 622     host_list_size -= HOST_LIST_GROW_STEP;
 623   }
 624   host_list =
 625       GNUNET_realloc (host_list,
 626                       sizeof (struct GNUNET_TESTBED_Host *) * host_list_size);
 627 }
 628
 629
 630 /**
 631  * Marks a host as registered with a controller
 632  *
 633  * @param host the host to mark
 634  * @param controller the controller at which this host is registered
 635  */
 636 void
 637 GNUNET_TESTBED_mark_host_registered_at_ (struct GNUNET_TESTBED_Host *host,
 638                                          const struct GNUNET_TESTBED_Controller
 639                                          *const controller)
 640 {
 641   struct RegisteredController *rc;
 642
 643   for (rc = host->rc_head; NULL != rc; rc = rc->next)
 644   {
 645     if (controller == rc->controller)   /* already registered at controller */
 646     {
 647       GNUNET_break (0);
 648       return;
 649     }
 650   }
 651   rc = GNUNET_new (struct RegisteredController);
 652   rc->controller = controller;
 653   GNUNET_CONTAINER_DLL_insert_tail (host->rc_head, host->rc_tail, rc);
 654 }
 655
 656
 657 /**
 658  * Unmarks a host registered at a controller
 659  *
 660  * @param host the host to unmark
 661  * @param controller the controller at which this host has to be unmarked
 662  */
 663 void
 664 GNUNET_TESTBED_deregister_host_at_ (struct GNUNET_TESTBED_Host *host,
 665                                     const struct GNUNET_TESTBED_Controller
 666                                     *const controller)
 667 {
 668   struct RegisteredController *rc;
 669
 670   for (rc = host->rc_head; NULL != rc; rc=rc->next)
 671     if (controller == rc->controller)
 672       break;
 673   if (NULL == rc)
 674   {
 675     GNUNET_break (0);
 676     return;
 677   }
 678   GNUNET_CONTAINER_DLL_remove (host->rc_head, host->rc_tail, rc);
 679   GNUNET_free (rc);
 680 }
 681
 682
 683 /**
 684  * Checks whether a host has been registered
 685  *
 686  * @param host the host to check
 687  * @param controller the controller at which host's registration is checked
 688  * @return GNUNET_YES if registered; GNUNET_NO if not
 689  */
 690 int
 691 GNUNET_TESTBED_is_host_registered_ (const struct GNUNET_TESTBED_Host *host,
 692                                     const struct GNUNET_TESTBED_Controller
 693                                     *const controller)
 694 {
 695   struct RegisteredController *rc;
 696
 697   for (rc = host->rc_head; NULL != rc; rc = rc->next)
 698   {
 699     if (controller == rc->controller)   /* already registered at controller */
 700     {
 701       return GNUNET_YES;
 702     }
 703   }
 704   return GNUNET_NO;
 705 }
 706
 707
 708 /**
 709  * Handle for controller process
 710  */
 711 struct GNUNET_TESTBED_ControllerProc
 712 {
 713   /**
 714    * The process handle
 715    */
 716   struct GNUNET_HELPER_Handle *helper;
 717
 718   /**
 719    * The arguments used to start the helper
 720    */
 721   char **helper_argv;
 722
 723   /**
 724    * The host where the helper is run
 725    */
 726   struct GNUNET_TESTBED_Host *host;
 727
 728   /**
 729    * The controller error callback
 730    */
 731   GNUNET_TESTBED_ControllerStatusCallback cb;
 732
 733   /**
 734    * The closure for the above callback
 735    */
 736   void *cls;
 737
 738   /**
 739    * The send handle for the helper
 740    */
 741   struct GNUNET_HELPER_SendHandle *shandle;
 742
 743   /**
 744    * The message corresponding to send handle
 745    */
 746   struct GNUNET_MessageHeader *msg;
 747
 748 };
 749
 750
 751 /**
 752  * Function to copy NULL terminated list of arguments
 753  *
 754  * @param argv the NULL terminated list of arguments. Cannot be NULL.
 755  * @return the copied NULL terminated arguments
 756  */
 757 static char **
 758 copy_argv (const char *const *argv)
 759 {
 760   char **argv_dup;
 761   unsigned int argp;
 762
 763   GNUNET_assert (NULL != argv);
 764   for (argp = 0; NULL != argv[argp]; argp++) ;
 765   argv_dup = GNUNET_malloc (sizeof (char *) * (argp + 1));
 766   for (argp = 0; NULL != argv[argp]; argp++)
 767     argv_dup[argp] = GNUNET_strdup (argv[argp]);
 768   return argv_dup;
 769 }
 770
 771
 772 /**
 773  * Function to join NULL terminated list of arguments
 774  *
 775  * @param argv1 the NULL terminated list of arguments. Cannot be NULL.
 776  * @param argv2 the NULL terminated list of arguments. Cannot be NULL.
 777  * @return the joined NULL terminated arguments
 778  */
 779 static char **
 780 join_argv (const char *const *argv1, const char *const *argv2)
 781 {
 782   char **argvj;
 783   char *argv;
 784   unsigned int carg;
 785   unsigned int cnt;
 786
 787   carg = 0;
 788   argvj = NULL;
 789   for (cnt = 0; NULL != argv1[cnt]; cnt++)
 790   {
 791     argv = GNUNET_strdup (argv1[cnt]);
 792     GNUNET_array_append (argvj, carg, argv);
 793   }
 794   for (cnt = 0; NULL != argv2[cnt]; cnt++)
 795   {
 796     argv = GNUNET_strdup (argv2[cnt]);
 797     GNUNET_array_append (argvj, carg, argv);
 798   }
 799   GNUNET_array_append (argvj, carg, NULL);
 800   return argvj;
 801 }
 802
 803
 804 /**
 805  * Frees the given NULL terminated arguments
 806  *
 807  * @param argv the NULL terminated list of arguments
 808  */
 809 static void
 810 free_argv (char **argv)
 811 {
 812   unsigned int argp;
 813
 814   for (argp = 0; NULL != argv[argp]; argp++)
 815     GNUNET_free (argv[argp]);
 816   GNUNET_free (argv);
 817 }
 818
 819
 820 /**
 821  * Generates arguments for opening a remote shell. Builds up the arguments
 822  * from the environment variable GNUNET_TESTBED_RSH_CMD. The variable
 823  * should not mention `-p' (port) option and destination address as these will
 824  * be set locally in the function from its parameteres. If the environmental
 825  * variable is not found then it defaults to `ssh -o BatchMode=yes -o
 826  * NoHostAuthenticationForLocalhost=yes -o StrictHostkeyChecking=no -o
 827  * PasswordAuthentication=noc'
 828  *
 829  * @param port the destination port number
 830  * @param hostname the hostname of the target host
 831  * @param username the username to use while connecting to target host
 832  * @return NULL terminated list of arguments
 833  */
 834 static char **
 835 gen_rsh_args (const char *port, const char *hostname, const char *username)
 836 {
 837   static const char *default_ssh_args[] = {
 838     "ssh",
 839     "-o",
 840     "BatchMode=yes",
 841     "-o",
 842     "NoHostAuthenticationForLocalhost=yes",
 843     "-o",
 844     "StrictHostKeyChecking=no",
 845     "-o",
 846     "PasswordAuthentication=no",
 847     "%h",
 848     NULL
 849   };
 850   char **ssh_args;
 851   char *ssh_cmd;
 852   char *ssh_cmd_cp;
 853   char *arg;
 854   const char *new_arg;
 855   unsigned int size;
 856   unsigned int cnt;
 857
 858   ssh_args = NULL;
 859   if (NULL != (ssh_cmd = getenv ("GNUNET_TESTBED_RSH_CMD")))
 860   {
 861     ssh_cmd = GNUNET_strdup (ssh_cmd);
 862     ssh_cmd_cp = ssh_cmd;
 863     for (size = 0; NULL != (arg = strtok (ssh_cmd, " ")); ssh_cmd = NULL)
 864       GNUNET_array_append (ssh_args, size, GNUNET_strdup (arg));
 865     GNUNET_free (ssh_cmd_cp);
 866   }
 867   else
 868   {
 869     ssh_args = copy_argv (default_ssh_args);
 870     size = (sizeof (default_ssh_args)) / (sizeof (const char *));
 871     GNUNET_array_grow (ssh_args, size, size - 1);
 872   }
 873   for (cnt = 0; cnt < size; cnt++)
 874   {
 875     arg = ssh_args[cnt];
 876     if ('%' != arg[0])
 877       continue;
 878     switch (arg[1])
 879     {
 880     case 'p':
 881       new_arg = port;
 882       break;
 883
 884     case 'u':
 885       new_arg = username;
 886       break;
 887
 888     case 'h':
 889       new_arg = hostname;
 890       break;
 891
 892     default:
 893       continue;
 894     }
 895     if (NULL == new_arg)
 896       continue;
 897     GNUNET_free (arg);
 898     ssh_args[cnt] = GNUNET_strdup (new_arg);
 899   }
 900   GNUNET_array_append (ssh_args, size, NULL);
 901   return ssh_args;
 902 }
 903
 904
 905 /**
 906  * Generates the arguments needed for executing the given binary in a remote
 907  * shell. Builds the arguments from the environmental variable
 908  * GNUNET_TETSBED_RSH_CMD_SUFFIX. If the environmental variable is not found,
 909  * only the given binary name will be present in the returned arguments
 910  *
 911  * @param append_args the arguments to append after generating the suffix
 912  *          arguments. Can be NULL; if not must be NULL terminated 'char *' array
 913  * @return NULL-terminated args
 914  */
 915 static char **
 916 gen_rsh_suffix_args (const char * const *append_args)
 917 {
 918   char **rshell_args;
 919   char *rshell_cmd;
 920   char *rshell_cmd_cp;
 921   char *arg;
 922   unsigned int cnt;
 923   unsigned int append_cnt;
 924
 925   rshell_args = NULL;
 926   cnt = 0;
 927   if (NULL != (rshell_cmd = getenv ("GNUNET_TESTBED_RSH_CMD_SUFFIX")))
 928   {
 929     rshell_cmd = GNUNET_strdup (rshell_cmd);
 930     rshell_cmd_cp = rshell_cmd;
 931     for (; NULL != (arg = strtok (rshell_cmd, " ")); rshell_cmd = NULL)
 932       GNUNET_array_append (rshell_args, cnt, GNUNET_strdup (arg));
 933     GNUNET_free (rshell_cmd_cp);
 934   }
 935   if (NULL != append_args)
 936   {
 937     for (append_cnt = 0; NULL != append_args[append_cnt]; append_cnt++)
 938       GNUNET_array_append (rshell_args, cnt, GNUNET_strdup (append_args[append_cnt]));
 939   }
 940   GNUNET_array_append (rshell_args, cnt, NULL);
 941   return rshell_args;
 942 }
 943
 944
 945 /**
 946  * Functions with this signature are called whenever a
 947  * complete message is received by the tokenizer.
 948  *
 949  * Do not call GNUNET_SERVER_mst_destroy in callback
 950  *
 951  * @param cls closure
 952  * @param client identification of the client
 953  * @param message the actual message
 954  *
 955  * @return #GNUNET_OK on success, #GNUNET_SYSERR to stop further processing
 956  */
 957 static int
 958 helper_mst (void *cls,
 959             const struct GNUNET_MessageHeader *message)
 960 {
 961   struct GNUNET_TESTBED_ControllerProc *cp = cls;
 962   const struct GNUNET_TESTBED_HelperReply *msg;
 963   const char *hostname;
 964   char *config;
 965   uLongf config_size;
 966   uLongf xconfig_size;
 967
 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);
 974   xconfig_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,
 987                   config,
 988                   config_size,
 989                   NULL));
 990   GNUNET_free (config);
 991   if (NULL == (hostname = GNUNET_TESTBED_host_get_hostname (cp->host)))
 992     hostname = "localhost";
 993   /* Change the hostname so that we can connect to it */
 994   GNUNET_CONFIGURATION_set_value_string (cp->host->cfg, "testbed", "hostname",
 995                                          hostname);
 996   cp->host->locked = GNUNET_NO;
 997   cp->host->controller_started = GNUNET_YES;
 998   cp->cb (cp->cls, cp->host->cfg, GNUNET_OK);
 999   return GNUNET_OK;
1000 }
1001
1002
1003 /**
1004  * Continuation function from GNUNET_HELPER_send()
1005  *
1006  * @param cls closure
1007  * @param result GNUNET_OK on success,
1008  *               GNUNET_NO if helper process died
1009  *               GNUNET_SYSERR during GNUNET_HELPER_stop
1010  */
1011 static void
1012 clear_msg (void *cls, int result)
1013 {
1014   struct GNUNET_TESTBED_ControllerProc *cp = cls;
1015
1016   GNUNET_assert (NULL != cp->shandle);
1017   cp->shandle = NULL;
1018   GNUNET_free (cp->msg);
1019   cp->msg = NULL;
1020 }
1021
1022
1023 /**
1024  * Callback that will be called when the helper process dies. This is not called
1025  * when the helper process is stoped using GNUNET_HELPER_stop()
1026  *
1027  * @param cls the closure from GNUNET_HELPER_start()
1028  */
1029 static void
1030 helper_exp_cb (void *cls)
1031 {
1032   struct GNUNET_TESTBED_ControllerProc *cp = cls;
1033   GNUNET_TESTBED_ControllerStatusCallback cb;
1034   void *cb_cls;
1035
1036   cb = cp->cb;
1037   cb_cls = cp->cls;
1038   cp->helper = NULL;
1039   GNUNET_TESTBED_controller_stop (cp);
1040   if (NULL != cb)
1041     cb (cb_cls, NULL, GNUNET_SYSERR);
1042 }
1043
1044
1045 /**
1046  * Starts a controller process at the given host.  The given host's configration
1047  * is used as a Template configuration to use for the remote controller; the
1048  * remote controller will be started with a slightly modified configuration
1049  * (port numbers, unix domain sockets and service home values are changed as per
1050  * TESTING library on the remote host).  The modified configuration replaces the
1051  * host's existing configuration before signalling success through the
1052  * GNUNET_TESTBED_ControllerStatusCallback()
1053  *
1054  * @param trusted_ip the ip address of the controller which will be set as TRUSTED
1055  *          HOST(all connections form this ip are permitted by the testbed) when
1056  *          starting testbed controller at host. This can either be a single ip
1057  *          address or a network address in CIDR notation.
1058  * @param host the host where the controller has to be started.  CANNOT be NULL.
1059  * @param cb function called when the controller is successfully started or
1060  *          dies unexpectedly; GNUNET_TESTBED_controller_stop shouldn't be
1061  *          called if cb is called with GNUNET_SYSERR as status. Will never be
1062  *          called in the same task as 'GNUNET_TESTBED_controller_start'
1063  *          (synchronous errors will be signalled by returning NULL). This
1064  *          parameter cannot be NULL.
1065  * @param cls closure for above callbacks
1066  * @return the controller process handle, NULL on errors
1067  */
1068 struct GNUNET_TESTBED_ControllerProc *
1069 GNUNET_TESTBED_controller_start (const char *trusted_ip,
1070                                  struct GNUNET_TESTBED_Host *host,
1071                                  GNUNET_TESTBED_ControllerStatusCallback cb,
1072                                  void *cls)
1073 {
1074   struct GNUNET_TESTBED_ControllerProc *cp;
1075   struct GNUNET_TESTBED_HelperInit *msg;
1076   const struct GNUNET_CONFIGURATION_Handle *cfg;
1077   const char *hostname;
1078   static char *const binary_argv[] = {
1079     HELPER_TESTBED_BINARY, NULL
1080   };
1081
1082   GNUNET_assert (NULL != host);
1083   GNUNET_assert (NULL != (cfg = GNUNET_TESTBED_host_get_cfg_ (host)));
1084   hostname = NULL;
1085   API_VIOLATION (GNUNET_NO == host->locked,
1086                  "Host is already locked by a previous call to GNUNET_TESTBED_controller_start()");
1087   host->locked = GNUNET_YES;
1088   API_VIOLATION (GNUNET_NO == host->controller_started,
1089                  "Attempting to start a controller on a host which is already started a controller");
1090   cp = GNUNET_new (struct GNUNET_TESTBED_ControllerProc);
1091   if (0 == GNUNET_TESTBED_host_get_id_ (host))
1092   {
1093     cp->helper =
1094         GNUNET_HELPER_start (GNUNET_YES, HELPER_TESTBED_BINARY, binary_argv,
1095                              &helper_mst, &helper_exp_cb, cp);
1096   }
1097   else
1098   {
1099     char *helper_binary_path_args[2];
1100     char **rsh_args;
1101     char **rsh_suffix_args;
1102     const char *username;
1103     char *port;
1104     char *argstr;
1105     char *aux;
1106     unsigned int cnt;
1107
1108     username = host->username;
1109     hostname = host->hostname;
1110     GNUNET_asprintf (&port, "%u", host->port);
1111     LOG_DEBUG ("Starting remote connection to destination %s\n", hostname);
1112     if (GNUNET_OK !=
1113         GNUNET_CONFIGURATION_get_value_filename (cfg, "testbed",
1114                                                "HELPER_BINARY_PATH",
1115                                                &helper_binary_path_args[0]))
1116       helper_binary_path_args[0] =
1117           GNUNET_OS_get_libexec_binary_path (HELPER_TESTBED_BINARY);
1118     helper_binary_path_args[1] = NULL;
1119     rsh_args = gen_rsh_args (port, hostname, username);
1120     rsh_suffix_args = gen_rsh_suffix_args ((const char **) helper_binary_path_args);
1121     cp->helper_argv =
1122         join_argv ((const char **) rsh_args, (const char **) rsh_suffix_args);
1123     free_argv (rsh_args);
1124     free_argv (rsh_suffix_args);
1125     GNUNET_free (port);
1126     argstr = GNUNET_strdup ("");
1127     for (cnt = 0; NULL != cp->helper_argv[cnt]; cnt++)
1128     {
1129       aux = argstr;
1130       GNUNET_assert (0 < GNUNET_asprintf (&argstr, "%s %s", aux, cp->helper_argv[cnt]));
1131       GNUNET_free (aux);
1132     }
1133     LOG_DEBUG ("Helper cmd str: %s\n", argstr);
1134     GNUNET_free (argstr);
1135     cp->helper =
1136         GNUNET_HELPER_start (GNUNET_NO, cp->helper_argv[0], cp->helper_argv, &helper_mst,
1137                              &helper_exp_cb, cp);
1138     GNUNET_free (helper_binary_path_args[0]);
1139   }
1140   if (NULL == cp->helper)
1141   {
1142     if (NULL != cp->helper_argv)
1143       free_argv (cp->helper_argv);
1144     GNUNET_free (cp);
1145     return NULL;
1146   }
1147   cp->host = host;
1148   cp->cb = cb;
1149   cp->cls = cls;
1150   msg = GNUNET_TESTBED_create_helper_init_msg_ (trusted_ip, hostname, cfg);
1151   cp->msg = &msg->header;
1152   cp->shandle =
1153       GNUNET_HELPER_send (cp->helper, &msg->header, GNUNET_NO, &clear_msg, cp);
1154   if (NULL == cp->shandle)
1155   {
1156     GNUNET_free (msg);
1157     GNUNET_TESTBED_controller_stop (cp);
1158     return NULL;
1159   }
1160   return cp;
1161 }
1162
1163
1164 /**
1165  * Sends termination signal to the controller's helper process
1166  *
1167  * @param cproc the handle to the controller's helper process
1168  */
1169 void
1170 GNUNET_TESTBED_controller_kill_ (struct GNUNET_TESTBED_ControllerProc *cproc)
1171 {
1172   if (NULL != cproc->shandle)
1173     GNUNET_HELPER_send_cancel (cproc->shandle);
1174   if (NULL != cproc->helper)
1175     GNUNET_HELPER_kill (cproc->helper, GNUNET_YES);
1176 }
1177
1178
1179 /**
1180  * Cleans-up the controller's helper process handle
1181  *
1182  * @param cproc the handle to the controller's helper process
1183  */
1184 void
1185 GNUNET_TESTBED_controller_destroy_ (struct GNUNET_TESTBED_ControllerProc *cproc)
1186 {
1187   if (NULL != cproc->helper)
1188   {
1189     GNUNET_break (GNUNET_OK == GNUNET_HELPER_wait (cproc->helper));
1190     GNUNET_HELPER_destroy (cproc->helper);
1191   }
1192   if (NULL != cproc->helper_argv)
1193     free_argv (cproc->helper_argv);
1194   cproc->host->controller_started = GNUNET_NO;
1195   cproc->host->locked = GNUNET_NO;
1196   GNUNET_free_non_null (cproc->msg);
1197   GNUNET_free (cproc);
1198 }
1199
1200
1201 /**
1202  * Stop the controller process (also will terminate all peers and controllers
1203  * dependent on this controller).  This function blocks until the testbed has
1204  * been fully terminated (!). The controller status cb from
1205  * GNUNET_TESTBED_controller_start() will not be called.
1206  *
1207  * @param cproc the controller process handle
1208  */
1209 void
1210 GNUNET_TESTBED_controller_stop (struct GNUNET_TESTBED_ControllerProc *cproc)
1211 {
1212   GNUNET_TESTBED_controller_kill_ (cproc);
1213   GNUNET_TESTBED_controller_destroy_ (cproc);
1214 }
1215
1216
1217 /**
1218  * The handle for whether a host is habitable or not
1219  */
1220 struct GNUNET_TESTBED_HostHabitableCheckHandle
1221 {
1222   /**
1223    * The host to check
1224    */
1225   const struct GNUNET_TESTBED_Host *host;
1226
1227   /**
1228    * The callback to call once we have the status
1229    */
1230   GNUNET_TESTBED_HostHabitableCallback cb;
1231
1232   /**
1233    * The callback closure
1234    */
1235   void *cb_cls;
1236
1237   /**
1238    * The process handle for the SSH process
1239    */
1240   struct GNUNET_OS_Process *auxp;
1241
1242   /**
1243    * The arguments used to start the helper
1244    */
1245   char **helper_argv;
1246
1247   /**
1248    * Task id for the habitability check task
1249    */
1250   struct GNUNET_SCHEDULER_Task * habitability_check_task;
1251
1252   /**
1253    * How long we wait before checking the process status. Should grow
1254    * exponentially
1255    */
1256   struct GNUNET_TIME_Relative wait_time;
1257
1258 };
1259
1260
1261 /**
1262  * Task for checking whether a host is habitable or not
1263  *
1264  * @param cls GNUNET_TESTBED_HostHabitableCheckHandle
1265  */
1266 static void
1267 habitability_check (void *cls)
1268 {
1269   struct GNUNET_TESTBED_HostHabitableCheckHandle *h = cls;
1270   void *cb_cls;
1271   GNUNET_TESTBED_HostHabitableCallback cb;
1272   const struct GNUNET_TESTBED_Host *host;
1273   unsigned long code;
1274   enum GNUNET_OS_ProcessStatusType type;
1275   int ret;
1276
1277   h->habitability_check_task = NULL;
1278   ret = GNUNET_OS_process_status (h->auxp, &type, &code);
1279   if (GNUNET_SYSERR == ret)
1280   {
1281     GNUNET_break (0);
1282     ret = GNUNET_NO;
1283     goto call_cb;
1284   }
1285   if (GNUNET_NO == ret)
1286   {
1287     h->wait_time = GNUNET_TIME_STD_BACKOFF (h->wait_time);
1288     h->habitability_check_task =
1289         GNUNET_SCHEDULER_add_delayed (h->wait_time, &habitability_check, h);
1290     return;
1291   }
1292   GNUNET_OS_process_destroy (h->auxp);
1293   h->auxp = NULL;
1294   ret = (0 != code) ? GNUNET_NO : GNUNET_YES;
1295
1296 call_cb:
1297   if (NULL != h->auxp)
1298     GNUNET_OS_process_destroy (h->auxp);
1299   cb = h->cb;
1300   cb_cls = h->cb_cls;
1301   host = h->host;
1302   free_argv (h->helper_argv);
1303   GNUNET_free (h);
1304   if (NULL != cb)
1305     cb (cb_cls, host, ret);
1306 }
1307
1308
1309 /**
1310  * Checks whether a host can be used to start testbed service
1311  *
1312  * @param host the host to check
1313  * @param config the configuration handle to lookup the path of the testbed
1314  *          helper
1315  * @param cb the callback to call to inform about habitability of the given host
1316  * @param cb_cls the closure for the callback
1317  * @return NULL upon any error or a handle which can be passed to
1318  *           GNUNET_TESTBED_is_host_habitable_cancel()
1319  */
1320 struct GNUNET_TESTBED_HostHabitableCheckHandle *
1321 GNUNET_TESTBED_is_host_habitable (const struct GNUNET_TESTBED_Host *host,
1322                                   const struct GNUNET_CONFIGURATION_Handle
1323                                   *config,
1324                                   GNUNET_TESTBED_HostHabitableCallback cb,
1325                                   void *cb_cls)
1326 {
1327   struct GNUNET_TESTBED_HostHabitableCheckHandle *h;
1328   char **rsh_args;
1329   char **rsh_suffix_args;
1330   char *stat_args[3];
1331   const char *hostname;
1332   char *port;
1333
1334   h = GNUNET_new (struct GNUNET_TESTBED_HostHabitableCheckHandle);
1335   h->cb = cb;
1336   h->cb_cls = cb_cls;
1337   h->host = host;
1338   hostname = (NULL == host->hostname) ? "127.0.0.1" : host->hostname;
1339   if (GNUNET_OK !=
1340       GNUNET_CONFIGURATION_get_value_filename (config, "testbed",
1341                                              "HELPER_BINARY_PATH",
1342                                              &stat_args[1]))
1343     stat_args[1] =
1344         GNUNET_OS_get_libexec_binary_path (HELPER_TESTBED_BINARY);
1345   GNUNET_asprintf (&port, "%u", host->port);
1346   rsh_args = gen_rsh_args (port, hostname, host->username);
1347   GNUNET_free (port);
1348   port = NULL;
1349   stat_args[0] = "stat";
1350   stat_args[2] = NULL;
1351   rsh_suffix_args = gen_rsh_suffix_args ((const char **) stat_args);
1352   GNUNET_free (stat_args[1]);
1353   h->helper_argv = join_argv ((const char **) rsh_args,
1354                               (const char **) rsh_suffix_args);
1355   free_argv (rsh_suffix_args);
1356   free_argv (rsh_args);
1357   h->auxp =
1358       GNUNET_OS_start_process_vap (GNUNET_NO, GNUNET_OS_INHERIT_STD_ERR, NULL,
1359                                    NULL, NULL, h->helper_argv[0], h->helper_argv);
1360   if (NULL == h->auxp)
1361   {
1362     GNUNET_break (0);           /* Cannot exec SSH? */
1363     GNUNET_free (h);
1364     return NULL;
1365   }
1366   h->wait_time = GNUNET_TIME_STD_BACKOFF (h->wait_time);
1367   h->habitability_check_task =
1368       GNUNET_SCHEDULER_add_delayed (h->wait_time, &habitability_check, h);
1369   return h;
1370 }
1371
1372
1373 /**
1374  * Function to cancel a request started using GNUNET_TESTBED_is_host_habitable()
1375  *
1376  * @param handle the habitability check handle
1377  */
1378 void
1379 GNUNET_TESTBED_is_host_habitable_cancel (struct
1380                                          GNUNET_TESTBED_HostHabitableCheckHandle
1381                                          *handle)
1382 {
1383   GNUNET_SCHEDULER_cancel (handle->habitability_check_task);
1384   (void) GNUNET_OS_process_kill (handle->auxp, GNUNET_TERM_SIG);
1385   (void) GNUNET_OS_process_wait (handle->auxp);
1386   GNUNET_OS_process_destroy (handle->auxp);
1387   free_argv (handle->helper_argv);
1388   GNUNET_free (handle);
1389 }
1390
1391
1392 /**
1393  * Register a host with the controller
1394  *
1395  * @param controller the controller handle
1396  * @param host the host to register
1397  * @param cc the completion callback to call to inform the status of
1398  *          registration. After calling this callback the registration handle
1399  *          will be invalid. Cannot be NULL.
1400  * @param cc_cls the closure for the cc
1401  * @return handle to the host registration which can be used to cancel the
1402  *           registration
1403  */
1404 struct GNUNET_TESTBED_HostRegistrationHandle *
1405 GNUNET_TESTBED_register_host (struct GNUNET_TESTBED_Controller *controller,
1406                               struct GNUNET_TESTBED_Host *host,
1407                               GNUNET_TESTBED_HostRegistrationCompletion cc,
1408                               void *cc_cls)
1409 {
1410   struct GNUNET_TESTBED_HostRegistrationHandle *rh;
1411   struct GNUNET_TESTBED_AddHostMessage *msg;
1412   const char *username;
1413   const char *hostname;
1414   char *config;
1415   char *cconfig;
1416   void *ptr;
1417   size_t cc_size;
1418   size_t config_size;
1419   uint16_t msg_size;
1420   uint16_t username_length;
1421   uint16_t hostname_length;
1422
1423   if (NULL != controller->rh)
1424     return NULL;
1425   hostname = GNUNET_TESTBED_host_get_hostname (host);
1426   if (GNUNET_YES == GNUNET_TESTBED_is_host_registered_ (host, controller))
1427   {
1428     LOG (GNUNET_ERROR_TYPE_WARNING, "Host hostname: %s already registered\n",
1429          (NULL == hostname) ? "localhost" : hostname);
1430     return NULL;
1431   }
1432   rh = GNUNET_new (struct GNUNET_TESTBED_HostRegistrationHandle);
1433   rh->host = host;
1434   rh->c = controller;
1435   GNUNET_assert (NULL != cc);
1436   rh->cc = cc;
1437   rh->cc_cls = cc_cls;
1438   controller->rh = rh;
1439   username = GNUNET_TESTBED_host_get_username_ (host);
1440   username_length = 0;
1441   if (NULL != username)
1442     username_length = strlen (username);
1443   GNUNET_assert (NULL != hostname); /* Hostname must be present */
1444   hostname_length = strlen (hostname);
1445   GNUNET_assert (NULL != host->cfg);
1446   config = GNUNET_CONFIGURATION_serialize (host->cfg, &config_size);
1447   cc_size = GNUNET_TESTBED_compress_config_ (config, config_size, &cconfig);
1448   GNUNET_free (config);
1449   msg_size = (sizeof (struct GNUNET_TESTBED_AddHostMessage));
1450   msg_size += username_length;
1451   msg_size += hostname_length;
1452   msg_size += cc_size;
1453   msg = GNUNET_malloc (msg_size);
1454   msg->header.size = htons (msg_size);
1455   msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST);
1456   msg->host_id = htonl (GNUNET_TESTBED_host_get_id_ (host));
1457   msg->ssh_port = htons (GNUNET_TESTBED_host_get_ssh_port_ (host));
1458   ptr = &msg[1];
1459   if (NULL != username)
1460   {
1461     msg->username_length = htons (username_length);
1462     GNUNET_memcpy (ptr, username, username_length);
1463     ptr += username_length;
1464   }
1465   msg->hostname_length = htons (hostname_length);
1466   GNUNET_memcpy (ptr, hostname, hostname_length);
1467   ptr += hostname_length;
1468   msg->config_size = htons (config_size);
1469   GNUNET_memcpy (ptr, cconfig, cc_size);
1470   ptr += cc_size;
1471   GNUNET_assert ((ptr - (void *) msg) == msg_size);
1472   GNUNET_free (cconfig);
1473   GNUNET_TESTBED_queue_message_ (controller,
1474                                  (struct GNUNET_MessageHeader *) msg);
1475   return rh;
1476 }
1477
1478
1479 /**
1480  * Cancel the pending registration. Note that if the registration message is
1481  * already sent to the service the cancellation has only the effect that the
1482  * registration completion callback for the registration is never called.
1483  *
1484  * @param handle the registration handle to cancel
1485  */
1486 void
1487 GNUNET_TESTBED_cancel_registration (struct GNUNET_TESTBED_HostRegistrationHandle
1488                                     *handle)
1489 {
1490   if (handle != handle->c->rh)
1491   {
1492     GNUNET_break (0);
1493     return;
1494   }
1495   handle->c->rh = NULL;
1496   GNUNET_free (handle);
1497 }
1498
1499
1500 /**
1501  * Queues the given operation in the queue for parallel overlay connects of the
1502  * given host
1503  *
1504  * @param h the host handle
1505  * @param op the operation to queue in the given host's parally overlay connect
1506  *          queue
1507  */
1508 void
1509 GNUNET_TESTBED_host_queue_oc_ (struct GNUNET_TESTBED_Host *h,
1510                                struct GNUNET_TESTBED_Operation *op)
1511 {
1512   GNUNET_TESTBED_operation_queue_insert_
1513       (h->opq_parallel_overlay_connect_operations, op);
1514 }
1515
1516
1517 /**
1518  * Resolves the hostname of the host to an ip address
1519  *
1520  * @param host the host whose hostname is to be resolved
1521  */
1522 void
1523 GNUNET_TESTBED_host_resolve_ (struct GNUNET_TESTBED_Host *host)
1524 {
1525   char *hostname;
1526
1527   hostname = (char *) host->hostname;
1528   host->hostname = simple_resolve (hostname);
1529   if (NULL == host->hostname)
1530   {
1531     GNUNET_break (0);
1532     host->hostname = hostname;
1533     return;
1534   }
1535   GNUNET_free (hostname);
1536   host->hostname = GNUNET_strdup (host->hostname);
1537 }
1538
1539 /* end of testbed_api_hosts.c */