src/testbed/testbed_api_hosts.c

   1 /*
   2       This file is part of GNUnet
   3       (C) 2008--2013 Christian Grothoff (and other contributing authors)
   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., 59 Temple Place - Suite 330,
  18       Boston, MA 02111-1307, 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
 206                                    *cfg)
 207 {
 208   return GNUNET_TESTBED_host_create_with_id (id, NULL, NULL, cfg, 0);
 209 }
 210
 211
 212 /**
 213  * Obtain the host's unique global ID.
 214  *
 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)
 218  */
 219 uint32_t
 220 GNUNET_TESTBED_host_get_id_ (const struct GNUNET_TESTBED_Host * host)
 221 {
 222   return host->id;
 223 }
 224
 225
 226 /**
 227  * Obtain the host's hostname.
 228  *
 229  * @param host handle to the host, NULL means 'localhost'
 230  * @return hostname of the host
 231  */
 232 const char *
 233 GNUNET_TESTBED_host_get_hostname (const struct GNUNET_TESTBED_Host *host)
 234 {
 235   return host->hostname;
 236 }
 237
 238
 239 /**
 240  * Obtain the host's username
 241  *
 242  * @param host handle to the host, NULL means 'localhost'
 243  * @return username to login to the host
 244  */
 245 const char *
 246 GNUNET_TESTBED_host_get_username_ (const struct GNUNET_TESTBED_Host *host)
 247 {
 248   return host->username;
 249 }
 250
 251
 252 /**
 253  * Obtain the host's ssh port
 254  *
 255  * @param host handle to the host, NULL means 'localhost'
 256  * @return username to login to the host
 257  */
 258 uint16_t
 259 GNUNET_TESTBED_host_get_ssh_port_ (const struct GNUNET_TESTBED_Host * host)
 260 {
 261   return host->port;
 262 }
 263
 264
 265 /**
 266  * Check whether a controller is already started on the given host
 267  *
 268  * @param host the handle to the host
 269  * @return GNUNET_YES if the controller is already started; GNUNET_NO if not
 270  */
 271 int
 272 GNUNET_TESTBED_host_controller_started (const struct GNUNET_TESTBED_Host *host)
 273 {
 274   return host->controller_started;
 275 }
 276
 277
 278 /**
 279  * Obtain the host's configuration template
 280  *
 281  * @param host handle to the host
 282  * @return the host's configuration template
 283  */
 284 const struct GNUNET_CONFIGURATION_Handle *
 285 GNUNET_TESTBED_host_get_cfg_ (const struct GNUNET_TESTBED_Host *host)
 286 {
 287   return host->cfg;
 288 }
 289
 290
 291 /**
 292  * Function to replace host's configuration
 293  *
 294  * @param host the host handle
 295  * @param new_cfg the new configuration to replace the old one
 296  */
 297 void
 298 GNUNET_TESTBED_host_replace_cfg_ (struct GNUNET_TESTBED_Host *host,
 299                                   const struct GNUNET_CONFIGURATION_Handle *new_cfg)
 300 {
 301   GNUNET_CONFIGURATION_destroy (host->cfg);
 302   host->cfg = GNUNET_CONFIGURATION_dup (new_cfg);
 303 }
 304
 305
 306 /**
 307  * Create a host to run peers and controllers on.
 308  *
 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
 318  */
 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
 323                                     *cfg,
 324                                     uint16_t port)
 325 {
 326   struct GNUNET_TESTBED_Host *host;
 327   unsigned int new_size;
 328
 329   if ((id < host_list_size) && (NULL != host_list[id]))
 330   {
 331     LOG (GNUNET_ERROR_TYPE_WARNING, "Host with id: %u already created\n", id);
 332     return NULL;
 333   }
 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;
 337   host->id = id;
 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,
 342                                               UINT_MAX);
 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;
 351   return host;
 352 }
 353
 354
 355 /**
 356  * Create a host to run peers and controllers on.
 357  *
 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
 365  */
 366 struct GNUNET_TESTBED_Host *
 367 GNUNET_TESTBED_host_create (const char *hostname, const char *username,
 368                             const struct GNUNET_CONFIGURATION_Handle *cfg,
 369                             uint16_t port)
 370 {
 371   static uint32_t uid_generator;
 372
 373   if (NULL == hostname)
 374     return GNUNET_TESTBED_host_create_with_id (0, hostname, username,
 375                                                cfg, port);
 376   return GNUNET_TESTBED_host_create_with_id (++uid_generator, hostname,
 377                                              username, cfg, port);
 378 }
 379
 380
 381 /**
 382  * Load a set of hosts from a configuration file.
 383  *
 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
 391  */
 392 unsigned int
 393 GNUNET_TESTBED_hosts_load_from_file (const char *filename,
 394                                      const struct GNUNET_CONFIGURATION_Handle
 395                                      *cfg,
 396                                      struct GNUNET_TESTBED_Host ***hosts)
 397 {
 398   //struct GNUNET_TESTBED_Host **host_array;
 399   struct GNUNET_TESTBED_Host *starting_host;
 400   char *data;
 401   char *buf;
 402   char *username;
 403   char *hostname;
 404   regex_t rex;
 405   regmatch_t pmatch[6];
 406   uint64_t fs;
 407   short int port;
 408   unsigned int offset;
 409   unsigned int count;
 410
 411
 412   GNUNET_assert (NULL != filename);
 413   if (GNUNET_YES != GNUNET_DISK_file_test (filename))
 414   {
 415     LOG (GNUNET_ERROR_TYPE_WARNING, _("Hosts file %s not found\n"), filename);
 416     return 0;
 417   }
 418   if (GNUNET_OK !=
 419       GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
 420     fs = 0;
 421   if (0 == fs)
 422   {
 423     LOG (GNUNET_ERROR_TYPE_WARNING, _("Hosts file %s has no data\n"), filename);
 424     return 0;
 425   }
 426   data = GNUNET_malloc (fs);
 427   if (fs != GNUNET_DISK_fn_read (filename, data, fs))
 428   {
 429     GNUNET_free (data);
 430     LOG (GNUNET_ERROR_TYPE_WARNING, _("Hosts file %s cannot be read\n"),
 431          filename);
 432     return 0;
 433   }
 434   buf = data;
 435   offset = 0;
 436   starting_host = NULL;
 437   count = 0;
 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))
 445   {
 446     offset++;
 447     if (((data[offset] == '\n')) && (buf != &data[offset]))
 448     {
 449       unsigned int size;
 450
 451       data[offset] = '\0';
 452       username = NULL;
 453       hostname = NULL;
 454       port = 0;
 455       if ((REG_NOMATCH == regexec (&rex, buf, 6, pmatch, 0))
 456           || (-1 == pmatch[3].rm_so))
 457       {
 458         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 459                     "Error reading line `%s' in hostfile\n", buf);
 460         buf = &data[offset + 1];
 461         continue;
 462       }
 463       if (-1 != pmatch[2].rm_so)
 464       {
 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));
 469       }
 470       if (-1 != pmatch[5].rm_so)
 471       {
 472         (void) SSCANF (buf + pmatch[5].rm_so, "%5hd", &port);
 473       }
 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,
 481            port,
 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,
 487                                                     port);
 488       else
 489         (void) GNUNET_TESTBED_host_create (hostname, username, cfg, port);
 490       count++;
 491       GNUNET_free_non_null (username);
 492       GNUNET_free (hostname);
 493       buf = &data[offset + 1];
 494     }
 495     else if ((data[offset] == '\n') || (data[offset] == '\0'))
 496       buf = &data[offset + 1];
 497   }
 498   regfree (&rex);
 499   GNUNET_free (data);
 500   if (NULL == starting_host)
 501     return 0;
 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);
 505   return count;
 506 }
 507
 508
 509 /**
 510  * Resolves a hostname using getaddrinfo
 511  *
 512  * @param host the hostname
 513  * @return the string representing the IPv4 address of the given host; NULL upon error
 514  */
 515 const char *
 516 simple_resolve (const char *host)
 517 {
 518   struct addrinfo *res;
 519   const struct sockaddr_in *in_addr;
 520   char *hostip;
 521   struct addrinfo hint;
 522   unsigned int rc;
 523
 524   hint.ai_family = AF_INET;     /* IPv4 */
 525   hint.ai_socktype = 0;
 526   hint.ai_protocol = 0;
 527   hint.ai_addrlen = 0;
 528   hint.ai_addr = NULL;
 529   hint.ai_canonname = NULL;
 530   hint.ai_next = NULL;
 531   hint.ai_flags = AI_NUMERICSERV;
 532   res = NULL;
 533   LOG_DEBUG ("Resolving [%s]\n", host);
 534   if (0 != (rc = getaddrinfo (host, "22", &hint, &res)))
 535   {
 536     LOG_GAI (GNUNET_ERROR_TYPE_ERROR, "getaddrinfo", rc);
 537     return NULL;
 538   }
 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);
 545   freeaddrinfo (res);
 546   LOG_DEBUG ("Resolved [%s] to [%s]\n", host, hostip);
 547   return hostip;
 548 }
 549
 550
 551 /**
 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
 555  *
 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
 562  */
 563 unsigned int
 564 GNUNET_TESTBED_hosts_load_from_loadleveler (const struct
 565                                             GNUNET_CONFIGURATION_Handle *cfg,
 566                                             struct GNUNET_TESTBED_Host ***hosts)
 567 {
 568 #if !ENABLE_SUPERMUC
 569   LOG (GNUNET_ERROR_TYPE_ERROR,
 570        _("The function %s is only available when compiled with (--with-ll)\n"),
 571        __func__);
 572   GNUNET_assert (0);
 573 #else
 574   const char *hostfile;
 575
 576   if (NULL == (hostfile = getenv ("MP_SAVEHOSTFILE")))
 577   {
 578     GNUNET_break (0);
 579     return 0;
 580   }
 581   return GNUNET_TESTBED_hosts_load_from_file (hostfile, cfg, hosts);
 582 #endif
 583 }
 584
 585
 586 /**
 587  * Destroy a host handle.  Must only be called once everything
 588  * running on that host has been stopped.
 589  *
 590  * @param host handle to destroy
 591  */
 592 void
 593 GNUNET_TESTBED_host_destroy (struct GNUNET_TESTBED_Host *host)
 594 {
 595   struct RegisteredController *rc;
 596   uint32_t id;
 597
 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)
 603   {
 604     GNUNET_CONTAINER_DLL_remove (host->rc_head, host->rc_tail, rc);
 605     GNUNET_free (rc);
 606   }
 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);
 612   GNUNET_free (host);
 613   while (host_list_size >= HOST_LIST_GROW_STEP)
 614   {
 615     for (id = host_list_size - 1; id > host_list_size - HOST_LIST_GROW_STEP;
 616          id--)
 617       if (NULL != host_list[id])
 618         break;
 619     if (id != host_list_size - HOST_LIST_GROW_STEP)
 620       break;
 621     if (NULL != host_list[id])
 622       break;
 623     host_list_size -= HOST_LIST_GROW_STEP;
 624   }
 625   host_list =
 626       GNUNET_realloc (host_list,
 627                       sizeof (struct GNUNET_TESTBED_Host *) * host_list_size);
 628 }
 629
 630
 631 /**
 632  * Marks a host as registered with a controller
 633  *
 634  * @param host the host to mark
 635  * @param controller the controller at which this host is registered
 636  */
 637 void
 638 GNUNET_TESTBED_mark_host_registered_at_ (struct GNUNET_TESTBED_Host *host,
 639                                          const struct GNUNET_TESTBED_Controller
 640                                          *const controller)
 641 {
 642   struct RegisteredController *rc;
 643
 644   for (rc = host->rc_head; NULL != rc; rc = rc->next)
 645   {
 646     if (controller == rc->controller)   /* already registered at controller */
 647     {
 648       GNUNET_break (0);
 649       return;
 650     }
 651   }
 652   rc = GNUNET_new (struct RegisteredController);
 653   rc->controller = controller;
 654   GNUNET_CONTAINER_DLL_insert_tail (host->rc_head, host->rc_tail, rc);
 655 }
 656
 657
 658 /**
 659  * Unmarks a host registered at a controller
 660  *
 661  * @param host the host to unmark
 662  * @param controller the controller at which this host has to be unmarked
 663  */
 664 void
 665 GNUNET_TESTBED_deregister_host_at_ (struct GNUNET_TESTBED_Host *host,
 666                                     const struct GNUNET_TESTBED_Controller
 667                                     *const controller)
 668 {
 669   struct RegisteredController *rc;
 670
 671   for (rc = host->rc_head; NULL != rc; rc=rc->next)
 672     if (controller == rc->controller)
 673       break;
 674   if (NULL == rc)
 675   {
 676     GNUNET_break (0);
 677     return;
 678   }
 679   GNUNET_CONTAINER_DLL_remove (host->rc_head, host->rc_tail, rc);
 680   GNUNET_free (rc);
 681 }
 682
 683
 684 /**
 685  * Checks whether a host has been registered
 686  *
 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
 690  */
 691 int
 692 GNUNET_TESTBED_is_host_registered_ (const struct GNUNET_TESTBED_Host *host,
 693                                     const struct GNUNET_TESTBED_Controller
 694                                     *const controller)
 695 {
 696   struct RegisteredController *rc;
 697
 698   for (rc = host->rc_head; NULL != rc; rc = rc->next)
 699   {
 700     if (controller == rc->controller)   /* already registered at controller */
 701     {
 702       return GNUNET_YES;
 703     }
 704   }
 705   return GNUNET_NO;
 706 }
 707
 708
 709 /**
 710  * Handle for controller process
 711  */
 712 struct GNUNET_TESTBED_ControllerProc
 713 {
 714   /**
 715    * The process handle
 716    */
 717   struct GNUNET_HELPER_Handle *helper;
 718
 719   /**
 720    * The arguments used to start the helper
 721    */
 722   char **helper_argv;
 723
 724   /**
 725    * The host where the helper is run
 726    */
 727   struct GNUNET_TESTBED_Host *host;
 728
 729   /**
 730    * The controller error callback
 731    */
 732   GNUNET_TESTBED_ControllerStatusCallback cb;
 733
 734   /**
 735    * The closure for the above callback
 736    */
 737   void *cls;
 738
 739   /**
 740    * The send handle for the helper
 741    */
 742   struct GNUNET_HELPER_SendHandle *shandle;
 743
 744   /**
 745    * The message corresponding to send handle
 746    */
 747   struct GNUNET_MessageHeader *msg;
 748
 749 };
 750
 751
 752 /**
 753  * Function to copy NULL terminated list of arguments
 754  *
 755  * @param argv the NULL terminated list of arguments. Cannot be NULL.
 756  * @return the copied NULL terminated arguments
 757  */
 758 static char **
 759 copy_argv (const char *const *argv)
 760 {
 761   char **argv_dup;
 762   unsigned int argp;
 763
 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] = strdup (argv[argp]);
 769   return argv_dup;
 770 }
 771
 772
 773 /**
 774  * Function to join NULL terminated list of arguments
 775  *
 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
 779  */
 780 static char **
 781 join_argv (const char *const *argv1, const char *const *argv2)
 782 {
 783   char **argvj;
 784   char *argv;
 785   unsigned int carg;
 786   unsigned int cnt;
 787
 788   carg = 0;
 789   argvj = NULL;
 790   for (cnt = 0; NULL != argv1[cnt]; cnt++)
 791   {
 792     argv = GNUNET_strdup (argv1[cnt]);
 793     GNUNET_array_append (argvj, carg, argv);
 794   }
 795   for (cnt = 0; NULL != argv2[cnt]; cnt++)
 796   {
 797     argv = GNUNET_strdup (argv2[cnt]);
 798     GNUNET_array_append (argvj, carg, argv);
 799   }
 800   GNUNET_array_append (argvj, carg, NULL);
 801   return argvj;
 802 }
 803
 804
 805 /**
 806  * Frees the given NULL terminated arguments
 807  *
 808  * @param argv the NULL terminated list of arguments
 809  */
 810 static void
 811 free_argv (char **argv)
 812 {
 813   unsigned int argp;
 814
 815   for (argp = 0; NULL != argv[argp]; argp++)
 816     GNUNET_free (argv[argp]);
 817   GNUNET_free (argv);
 818 }
 819
 820
 821 /**
 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'
 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     "%h",
 844     NULL
 845   };
 846   char **ssh_args;
 847   char *ssh_cmd;
 848   char *ssh_cmd_cp;
 849   char *arg;
 850   const char *new_arg;
 851   unsigned int size;
 852   unsigned int cnt;
 853
 854   ssh_args = NULL;
 855   if (NULL != (ssh_cmd = getenv ("GNUNET_TESTBED_RSH_CMD")))
 856   {
 857     ssh_cmd = GNUNET_strdup (ssh_cmd);
 858     ssh_cmd_cp = ssh_cmd;
 859     for (size = 0; NULL != (arg = strtok (ssh_cmd, " ")); ssh_cmd = NULL)
 860       GNUNET_array_append (ssh_args, size, GNUNET_strdup (arg));
 861     GNUNET_free (ssh_cmd_cp);
 862   }
 863   else
 864   {
 865     ssh_args = copy_argv (default_ssh_args);
 866     size = (sizeof (default_ssh_args)) / (sizeof (const char *));
 867     GNUNET_array_grow (ssh_args, size, size - 1);
 868   }
 869   for (cnt = 0; cnt < size; cnt++)
 870   {
 871     arg = ssh_args[cnt];
 872     if ('%' != arg[0])
 873       continue;
 874     switch (arg[1])
 875     {
 876     case 'p':
 877       new_arg = port;
 878       break;
 879
 880     case 'u':
 881       new_arg = username;
 882       break;
 883
 884     case 'h':
 885       new_arg = hostname;
 886       break;
 887
 888     default:
 889       continue;
 890     }
 891     if (NULL == new_arg)
 892       continue;
 893     GNUNET_free (arg);
 894     ssh_args[cnt] = GNUNET_strdup (new_arg);
 895   }
 896   GNUNET_array_append (ssh_args, size, NULL);
 897   return ssh_args;
 898 }
 899
 900
 901 /**
 902  * Generates the arguments needed for executing the given binary in a remote
 903  * shell. Builds the arguments from the environmental variable
 904  * GNUNET_TETSBED_RSH_CMD_SUFFIX. If the environmental variable is not found,
 905  * only the given binary name will be present in the returned arguments
 906  *
 907  * @param append_args the arguments to append after generating the suffix
 908  *          arguments. Can be NULL; if not must be NULL terminated 'char *' array
 909  * @return NULL-terminated args
 910  */
 911 static char **
 912 gen_rsh_suffix_args (const char * const *append_args)
 913 {
 914   char **rshell_args;
 915   char *rshell_cmd;
 916   char *rshell_cmd_cp;
 917   char *arg;
 918   unsigned int cnt;
 919   unsigned int append_cnt;
 920
 921   rshell_args = NULL;
 922   cnt = 0;
 923   if (NULL != (rshell_cmd = getenv ("GNUNET_TESTBED_RSH_CMD_SUFFIX")))
 924   {
 925     rshell_cmd = GNUNET_strdup (rshell_cmd);
 926     rshell_cmd_cp = rshell_cmd;
 927     for (; NULL != (arg = strtok (rshell_cmd, " ")); rshell_cmd = NULL)
 928       GNUNET_array_append (rshell_args, cnt, GNUNET_strdup (arg));
 929     GNUNET_free (rshell_cmd_cp);
 930   }
 931   if (NULL != append_args)
 932   {
 933     for (append_cnt = 0; NULL != append_args[append_cnt]; append_cnt++)
 934       GNUNET_array_append (rshell_args, cnt, GNUNET_strdup (append_args[append_cnt]));
 935   }
 936   GNUNET_array_append (rshell_args, cnt, NULL);
 937   return rshell_args;
 938 }
 939
 940
 941 /**
 942  * Functions with this signature are called whenever a
 943  * complete message is received by the tokenizer.
 944  *
 945  * Do not call GNUNET_SERVER_mst_destroy in callback
 946  *
 947  * @param cls closure
 948  * @param client identification of the client
 949  * @param message the actual message
 950  *
 951  * @return GNUNET_OK on success, GNUNET_SYSERR to stop further processing
 952  */
 953 static int
 954 helper_mst (void *cls, void *client, const struct GNUNET_MessageHeader *message)
 955 {
 956   struct GNUNET_TESTBED_ControllerProc *cp = cls;
 957   const struct GNUNET_TESTBED_HelperReply *msg;
 958   const char *hostname;
 959   char *config;
 960   uLongf config_size;
 961   uLongf xconfig_size;
 962
 963   msg = (const struct GNUNET_TESTBED_HelperReply *) message;
 964   GNUNET_assert (sizeof (struct GNUNET_TESTBED_HelperReply) <
 965                  ntohs (msg->header.size));
 966   GNUNET_assert (GNUNET_MESSAGE_TYPE_TESTBED_HELPER_REPLY ==
 967                  ntohs (msg->header.type));
 968   config_size = (uLongf) ntohs (msg->config_size);
 969   xconfig_size =
 970       (uLongf) (ntohs (msg->header.size) -
 971                 sizeof (struct GNUNET_TESTBED_HelperReply));
 972   config = GNUNET_malloc (config_size);
 973   GNUNET_assert (Z_OK ==
 974                  uncompress ((Bytef *) config, &config_size,
 975                              (const Bytef *) &msg[1], xconfig_size));
 976   /* Replace the configuration template present in the host with the
 977      controller's running configuration */
 978   GNUNET_CONFIGURATION_destroy (cp->host->cfg);
 979   cp->host->cfg = GNUNET_CONFIGURATION_create ();
 980   GNUNET_assert (GNUNET_CONFIGURATION_deserialize
 981                  (cp->host->cfg, config, config_size, GNUNET_NO));
 982   GNUNET_free (config);
 983   if (NULL == (hostname = GNUNET_TESTBED_host_get_hostname (cp->host)))
 984     hostname = "localhost";
 985   /* Change the hostname so that we can connect to it */
 986   GNUNET_CONFIGURATION_set_value_string (cp->host->cfg, "testbed", "hostname",
 987                                          hostname);
 988   cp->host->locked = GNUNET_NO;
 989   cp->host->controller_started = GNUNET_YES;
 990   cp->cb (cp->cls, cp->host->cfg, GNUNET_OK);
 991   return GNUNET_OK;
 992 }
 993
 994
 995 /**
 996  * Continuation function from GNUNET_HELPER_send()
 997  *
 998  * @param cls closure
 999  * @param result GNUNET_OK on success,
1000  *               GNUNET_NO if helper process died
1001  *               GNUNET_SYSERR during GNUNET_HELPER_stop
1002  */
1003 static void
1004 clear_msg (void *cls, int result)
1005 {
1006   struct GNUNET_TESTBED_ControllerProc *cp = cls;
1007
1008   GNUNET_assert (NULL != cp->shandle);
1009   cp->shandle = NULL;
1010   GNUNET_free (cp->msg);
1011   cp->msg = NULL;
1012 }
1013
1014
1015 /**
1016  * Callback that will be called when the helper process dies. This is not called
1017  * when the helper process is stoped using GNUNET_HELPER_stop()
1018  *
1019  * @param cls the closure from GNUNET_HELPER_start()
1020  */
1021 static void
1022 helper_exp_cb (void *cls)
1023 {
1024   struct GNUNET_TESTBED_ControllerProc *cp = cls;
1025   GNUNET_TESTBED_ControllerStatusCallback cb;
1026   void *cb_cls;
1027
1028   cb = cp->cb;
1029   cb_cls = cp->cls;
1030   cp->helper = NULL;
1031   GNUNET_TESTBED_controller_stop (cp);
1032   if (NULL != cb)
1033     cb (cb_cls, NULL, GNUNET_SYSERR);
1034 }
1035
1036
1037 /**
1038  * Starts a controller process at the given host.  The given host's configration
1039  * is used as a Template configuration to use for the remote controller; the
1040  * remote controller will be started with a slightly modified configuration
1041  * (port numbers, unix domain sockets and service home values are changed as per
1042  * TESTING library on the remote host).  The modified configuration replaces the
1043  * host's existing configuration before signalling success through the
1044  * GNUNET_TESTBED_ControllerStatusCallback()
1045  *
1046  * @param trusted_ip the ip address of the controller which will be set as TRUSTED
1047  *          HOST(all connections form this ip are permitted by the testbed) when
1048  *          starting testbed controller at host. This can either be a single ip
1049  *          address or a network address in CIDR notation.
1050  * @param host the host where the controller has to be started.  CANNOT be NULL.
1051  * @param cb function called when the controller is successfully started or
1052  *          dies unexpectedly; GNUNET_TESTBED_controller_stop shouldn't be
1053  *          called if cb is called with GNUNET_SYSERR as status. Will never be
1054  *          called in the same task as 'GNUNET_TESTBED_controller_start'
1055  *          (synchronous errors will be signalled by returning NULL). This
1056  *          parameter cannot be NULL.
1057  * @param cls closure for above callbacks
1058  * @return the controller process handle, NULL on errors
1059  */
1060 struct GNUNET_TESTBED_ControllerProc *
1061 GNUNET_TESTBED_controller_start (const char *trusted_ip,
1062                                  struct GNUNET_TESTBED_Host *host,
1063                                  GNUNET_TESTBED_ControllerStatusCallback cb,
1064                                  void *cls)
1065 {
1066   struct GNUNET_TESTBED_ControllerProc *cp;
1067   struct GNUNET_TESTBED_HelperInit *msg;
1068   const struct GNUNET_CONFIGURATION_Handle *cfg;
1069   const char *hostname;
1070   static char *const binary_argv[] = {
1071     HELPER_TESTBED_BINARY, NULL
1072   };
1073
1074   GNUNET_assert (NULL != host);
1075   GNUNET_assert (NULL != (cfg = GNUNET_TESTBED_host_get_cfg_ (host)));
1076   hostname = NULL;
1077   API_VIOLATION (GNUNET_NO == host->locked,
1078                  "Host is already locked by a previous call to GNUNET_TESTBED_controller_start()");
1079   host->locked = GNUNET_YES;
1080   API_VIOLATION (GNUNET_NO == host->controller_started,
1081                  "Attempting to start a controller on a host which is already started a controller");
1082   cp = GNUNET_new (struct GNUNET_TESTBED_ControllerProc);
1083   if (0 == GNUNET_TESTBED_host_get_id_ (host))
1084   {
1085     cp->helper =
1086         GNUNET_HELPER_start (GNUNET_YES, HELPER_TESTBED_BINARY, binary_argv,
1087                              &helper_mst, &helper_exp_cb, cp);
1088   }
1089   else
1090   {
1091     char *helper_binary_path_args[2];
1092     char **rsh_args;
1093     char **rsh_suffix_args;
1094     const char *username;
1095     char *port;
1096     char *argstr;
1097     char *aux;
1098     unsigned int cnt;
1099
1100     username = host->username;
1101     hostname = host->hostname;
1102     GNUNET_asprintf (&port, "%u", host->port);
1103     LOG_DEBUG ("Starting remote connection to destination %s\n", hostname);
1104     if (GNUNET_OK !=
1105         GNUNET_CONFIGURATION_get_value_filename (cfg, "testbed",
1106                                                "HELPER_BINARY_PATH",
1107                                                &helper_binary_path_args[0]))
1108       helper_binary_path_args[0] =
1109           GNUNET_OS_get_libexec_binary_path (HELPER_TESTBED_BINARY);
1110     helper_binary_path_args[1] = NULL;
1111     rsh_args = gen_rsh_args (port, hostname, username);
1112     rsh_suffix_args = gen_rsh_suffix_args ((const char **) helper_binary_path_args);
1113     cp->helper_argv =
1114         join_argv ((const char **) rsh_args, (const char **) rsh_suffix_args);
1115     free_argv (rsh_args);
1116     free_argv (rsh_suffix_args);
1117     GNUNET_free (port);
1118     argstr = GNUNET_strdup ("");
1119     for (cnt = 0; NULL != cp->helper_argv[cnt]; cnt++)
1120     {
1121       aux = argstr;
1122       GNUNET_assert (0 < GNUNET_asprintf (&argstr, "%s %s", aux, cp->helper_argv[cnt]));
1123       GNUNET_free (aux);
1124     }
1125     LOG_DEBUG ("Helper cmd str: %s\n", argstr);
1126     GNUNET_free (argstr);
1127     cp->helper =
1128         GNUNET_HELPER_start (GNUNET_NO, cp->helper_argv[0], cp->helper_argv, &helper_mst,
1129                              &helper_exp_cb, cp);
1130     GNUNET_free (helper_binary_path_args[0]);
1131   }
1132   if (NULL == cp->helper)
1133   {
1134     if (NULL != cp->helper_argv)
1135       free_argv (cp->helper_argv);
1136     GNUNET_free (cp);
1137     return NULL;
1138   }
1139   cp->host = host;
1140   cp->cb = cb;
1141   cp->cls = cls;
1142   msg = GNUNET_TESTBED_create_helper_init_msg_ (trusted_ip, hostname, cfg);
1143   cp->msg = &msg->header;
1144   cp->shandle =
1145       GNUNET_HELPER_send (cp->helper, &msg->header, GNUNET_NO, &clear_msg, cp);
1146   if (NULL == cp->shandle)
1147   {
1148     GNUNET_free (msg);
1149     GNUNET_TESTBED_controller_stop (cp);
1150     return NULL;
1151   }
1152   return cp;
1153 }
1154
1155
1156 /**
1157  * Sends termination signal to the controller's helper process
1158  *
1159  * @param cproc the handle to the controller's helper process
1160  */
1161 void
1162 GNUNET_TESTBED_controller_kill_ (struct GNUNET_TESTBED_ControllerProc *cproc)
1163 {
1164   if (NULL != cproc->shandle)
1165     GNUNET_HELPER_send_cancel (cproc->shandle);
1166   if (NULL != cproc->helper)
1167     GNUNET_HELPER_kill (cproc->helper, GNUNET_YES);
1168 }
1169
1170
1171 /**
1172  * Cleans-up the controller's helper process handle
1173  *
1174  * @param cproc the handle to the controller's helper process
1175  */
1176 void
1177 GNUNET_TESTBED_controller_destroy_ (struct GNUNET_TESTBED_ControllerProc *cproc)
1178 {
1179   if (NULL != cproc->helper)
1180   {
1181     GNUNET_break (GNUNET_OK == GNUNET_HELPER_wait (cproc->helper));
1182     GNUNET_HELPER_destroy (cproc->helper);
1183   }
1184   if (NULL != cproc->helper_argv)
1185     free_argv (cproc->helper_argv);
1186   cproc->host->controller_started = GNUNET_NO;
1187   cproc->host->locked = GNUNET_NO;
1188   GNUNET_free_non_null (cproc->msg);
1189   GNUNET_free (cproc);
1190 }
1191
1192
1193 /**
1194  * Stop the controller process (also will terminate all peers and controllers
1195  * dependent on this controller).  This function blocks until the testbed has
1196  * been fully terminated (!). The controller status cb from
1197  * GNUNET_TESTBED_controller_start() will not be called.
1198  *
1199  * @param cproc the controller process handle
1200  */
1201 void
1202 GNUNET_TESTBED_controller_stop (struct GNUNET_TESTBED_ControllerProc *cproc)
1203 {
1204   GNUNET_TESTBED_controller_kill_ (cproc);
1205   GNUNET_TESTBED_controller_destroy_ (cproc);
1206 }
1207
1208
1209 /**
1210  * The handle for whether a host is habitable or not
1211  */
1212 struct GNUNET_TESTBED_HostHabitableCheckHandle
1213 {
1214   /**
1215    * The host to check
1216    */
1217   const struct GNUNET_TESTBED_Host *host;
1218
1219   /**
1220    * The callback to call once we have the status
1221    */
1222   GNUNET_TESTBED_HostHabitableCallback cb;
1223
1224   /**
1225    * The callback closure
1226    */
1227   void *cb_cls;
1228
1229   /**
1230    * The process handle for the SSH process
1231    */
1232   struct GNUNET_OS_Process *auxp;
1233
1234   /**
1235    * The arguments used to start the helper
1236    */
1237   char **helper_argv;
1238
1239   /**
1240    * Task id for the habitability check task
1241    */
1242   GNUNET_SCHEDULER_TaskIdentifier habitability_check_task;
1243
1244   /**
1245    * How long we wait before checking the process status. Should grow
1246    * exponentially
1247    */
1248   struct GNUNET_TIME_Relative wait_time;
1249
1250 };
1251
1252
1253 /**
1254  * Task for checking whether a host is habitable or not
1255  *
1256  * @param cls GNUNET_TESTBED_HostHabitableCheckHandle
1257  * @param tc the scheduler task context
1258  */
1259 static void
1260 habitability_check (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1261 {
1262   struct GNUNET_TESTBED_HostHabitableCheckHandle *h = cls;
1263   void *cb_cls;
1264   GNUNET_TESTBED_HostHabitableCallback cb;
1265   const struct GNUNET_TESTBED_Host *host;
1266   unsigned long code;
1267   enum GNUNET_OS_ProcessStatusType type;
1268   int ret;
1269
1270   h->habitability_check_task = GNUNET_SCHEDULER_NO_TASK;
1271   ret = GNUNET_OS_process_status (h->auxp, &type, &code);
1272   if (GNUNET_SYSERR == ret)
1273   {
1274     GNUNET_break (0);
1275     ret = GNUNET_NO;
1276     goto call_cb;
1277   }
1278   if (GNUNET_NO == ret)
1279   {
1280     h->wait_time = GNUNET_TIME_STD_BACKOFF (h->wait_time);
1281     h->habitability_check_task =
1282         GNUNET_SCHEDULER_add_delayed (h->wait_time, &habitability_check, h);
1283     return;
1284   }
1285   GNUNET_OS_process_destroy (h->auxp);
1286   h->auxp = NULL;
1287   ret = (0 != code) ? GNUNET_NO : GNUNET_YES;
1288
1289 call_cb:
1290   if (NULL != h->auxp)
1291     GNUNET_OS_process_destroy (h->auxp);
1292   cb = h->cb;
1293   cb_cls = h->cb_cls;
1294   host = h->host;
1295   free_argv (h->helper_argv);
1296   GNUNET_free (h);
1297   if (NULL != cb)
1298     cb (cb_cls, host, ret);
1299 }
1300
1301
1302 /**
1303  * Checks whether a host can be used to start testbed service
1304  *
1305  * @param host the host to check
1306  * @param config the configuration handle to lookup the path of the testbed
1307  *          helper
1308  * @param cb the callback to call to inform about habitability of the given host
1309  * @param cb_cls the closure for the callback
1310  * @return NULL upon any error or a handle which can be passed to
1311  *           GNUNET_TESTBED_is_host_habitable_cancel()
1312  */
1313 struct GNUNET_TESTBED_HostHabitableCheckHandle *
1314 GNUNET_TESTBED_is_host_habitable (const struct GNUNET_TESTBED_Host *host,
1315                                   const struct GNUNET_CONFIGURATION_Handle
1316                                   *config,
1317                                   GNUNET_TESTBED_HostHabitableCallback cb,
1318                                   void *cb_cls)
1319 {
1320   struct GNUNET_TESTBED_HostHabitableCheckHandle *h;
1321   char **rsh_args;
1322   char **rsh_suffix_args;
1323   char *stat_args[3];
1324   const char *hostname;
1325   char *port;
1326
1327   h = GNUNET_new (struct GNUNET_TESTBED_HostHabitableCheckHandle);
1328   h->cb = cb;
1329   h->cb_cls = cb_cls;
1330   h->host = host;
1331   hostname = (NULL == host->hostname) ? "127.0.0.1" : host->hostname;
1332   if (GNUNET_OK !=
1333       GNUNET_CONFIGURATION_get_value_filename (config, "testbed",
1334                                              "HELPER_BINARY_PATH",
1335                                              &stat_args[1]))
1336     stat_args[1] =
1337         GNUNET_OS_get_libexec_binary_path (HELPER_TESTBED_BINARY);
1338   GNUNET_asprintf (&port, "%u", host->port);
1339   rsh_args = gen_rsh_args (port, hostname, host->username);
1340   GNUNET_free (port);
1341   port = NULL;
1342   stat_args[0] = "stat";
1343   stat_args[2] = NULL;
1344   rsh_suffix_args = gen_rsh_suffix_args ((const char **) stat_args);
1345   GNUNET_free (stat_args[1]);
1346   h->helper_argv = join_argv ((const char **) rsh_args,
1347                               (const char **) rsh_suffix_args);
1348   free_argv (rsh_suffix_args);
1349   free_argv (rsh_args);
1350   h->auxp =
1351       GNUNET_OS_start_process_vap (GNUNET_NO, GNUNET_OS_INHERIT_STD_ERR, NULL,
1352                                    NULL, NULL, h->helper_argv[0], h->helper_argv);
1353   if (NULL == h->auxp)
1354   {
1355     GNUNET_break (0);           /* Cannot exec SSH? */
1356     GNUNET_free (h);
1357     return NULL;
1358   }
1359   h->wait_time = GNUNET_TIME_STD_BACKOFF (h->wait_time);
1360   h->habitability_check_task =
1361       GNUNET_SCHEDULER_add_delayed (h->wait_time, &habitability_check, h);
1362   return h;
1363 }
1364
1365
1366 /**
1367  * Function to cancel a request started using GNUNET_TESTBED_is_host_habitable()
1368  *
1369  * @param handle the habitability check handle
1370  */
1371 void
1372 GNUNET_TESTBED_is_host_habitable_cancel (struct
1373                                          GNUNET_TESTBED_HostHabitableCheckHandle
1374                                          *handle)
1375 {
1376   GNUNET_SCHEDULER_cancel (handle->habitability_check_task);
1377   (void) GNUNET_OS_process_kill (handle->auxp, GNUNET_TERM_SIG);
1378   (void) GNUNET_OS_process_wait (handle->auxp);
1379   GNUNET_OS_process_destroy (handle->auxp);
1380   free_argv (handle->helper_argv);
1381   GNUNET_free (handle);
1382 }
1383
1384
1385 /**
1386  * handle for host registration
1387  */
1388 struct GNUNET_TESTBED_HostRegistrationHandle
1389 {
1390   /**
1391    * The host being registered
1392    */
1393   struct GNUNET_TESTBED_Host *host;
1394
1395   /**
1396    * The controller at which this host is being registered
1397    */
1398   struct GNUNET_TESTBED_Controller *c;
1399
1400   /**
1401    * The Registartion completion callback
1402    */
1403   GNUNET_TESTBED_HostRegistrationCompletion cc;
1404
1405   /**
1406    * The closure for above callback
1407    */
1408   void *cc_cls;
1409 };
1410
1411
1412 /**
1413  * Register a host with the controller
1414  *
1415  * @param controller the controller handle
1416  * @param host the host to register
1417  * @param cc the completion callback to call to inform the status of
1418  *          registration. After calling this callback the registration handle
1419  *          will be invalid. Cannot be NULL.
1420  * @param cc_cls the closure for the cc
1421  * @return handle to the host registration which can be used to cancel the
1422  *           registration
1423  */
1424 struct GNUNET_TESTBED_HostRegistrationHandle *
1425 GNUNET_TESTBED_register_host (struct GNUNET_TESTBED_Controller *controller,
1426                               struct GNUNET_TESTBED_Host *host,
1427                               GNUNET_TESTBED_HostRegistrationCompletion cc,
1428                               void *cc_cls)
1429 {
1430   struct GNUNET_TESTBED_HostRegistrationHandle *rh;
1431   struct GNUNET_TESTBED_AddHostMessage *msg;
1432   const char *username;
1433   const char *hostname;
1434   char *config;
1435   char *cconfig;
1436   void *ptr;
1437   size_t cc_size;
1438   size_t config_size;
1439   uint16_t msg_size;
1440   uint16_t username_length;
1441   uint16_t hostname_length;
1442
1443   if (NULL != controller->rh)
1444     return NULL;
1445   hostname = GNUNET_TESTBED_host_get_hostname (host);
1446   if (GNUNET_YES == GNUNET_TESTBED_is_host_registered_ (host, controller))
1447   {
1448     LOG (GNUNET_ERROR_TYPE_WARNING, "Host hostname: %s already registered\n",
1449          (NULL == hostname) ? "localhost" : hostname);
1450     return NULL;
1451   }
1452   rh = GNUNET_new (struct GNUNET_TESTBED_HostRegistrationHandle);
1453   rh->host = host;
1454   rh->c = controller;
1455   GNUNET_assert (NULL != cc);
1456   rh->cc = cc;
1457   rh->cc_cls = cc_cls;
1458   controller->rh = rh;
1459   username = GNUNET_TESTBED_host_get_username_ (host);
1460   username_length = 0;
1461   if (NULL != username)
1462     username_length = strlen (username);
1463   GNUNET_assert (NULL != hostname); /* Hostname must be present */
1464   hostname_length = strlen (hostname);
1465   GNUNET_assert (NULL != host->cfg);
1466   config = GNUNET_CONFIGURATION_serialize (host->cfg, &config_size);
1467   cc_size = GNUNET_TESTBED_compress_config_ (config, config_size, &cconfig);
1468   GNUNET_free (config);
1469   msg_size = (sizeof (struct GNUNET_TESTBED_AddHostMessage));
1470   msg_size += username_length;
1471   msg_size += hostname_length;
1472   msg_size += cc_size;
1473   msg = GNUNET_malloc (msg_size);
1474   msg->header.size = htons (msg_size);
1475   msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST);
1476   msg->host_id = htonl (GNUNET_TESTBED_host_get_id_ (host));
1477   msg->ssh_port = htons (GNUNET_TESTBED_host_get_ssh_port_ (host));
1478   ptr = &msg[1];
1479   if (NULL != username)
1480   {
1481     msg->username_length = htons (username_length);
1482     ptr = memcpy (ptr, username, username_length);
1483     ptr += username_length;
1484   }
1485   msg->hostname_length = htons (hostname_length);
1486   ptr = memcpy (ptr, hostname, hostname_length);
1487   ptr += hostname_length;
1488   msg->config_size = htons (config_size);
1489   ptr = memcpy (ptr, cconfig, cc_size);
1490   ptr += cc_size;
1491   GNUNET_assert ((ptr - (void *) msg) == msg_size);
1492   GNUNET_free (cconfig);
1493   GNUNET_TESTBED_queue_message_ (controller,
1494                                  (struct GNUNET_MessageHeader *) msg);
1495   return rh;
1496 }
1497
1498
1499 /**
1500  * Cancel the pending registration. Note that if the registration message is
1501  * already sent to the service the cancellation has only the effect that the
1502  * registration completion callback for the registration is never called.
1503  *
1504  * @param handle the registration handle to cancel
1505  */
1506 void
1507 GNUNET_TESTBED_cancel_registration (struct GNUNET_TESTBED_HostRegistrationHandle
1508                                     *handle)
1509 {
1510   if (handle != handle->c->rh)
1511   {
1512     GNUNET_break (0);
1513     return;
1514   }
1515   handle->c->rh = NULL;
1516   GNUNET_free (handle);
1517 }
1518
1519
1520 /**
1521  * Queues the given operation in the queue for parallel overlay connects of the
1522  * given host
1523  *
1524  * @param h the host handle
1525  * @param op the operation to queue in the given host's parally overlay connect
1526  *          queue
1527  */
1528 void
1529 GNUNET_TESTBED_host_queue_oc_ (struct GNUNET_TESTBED_Host *h,
1530                                struct GNUNET_TESTBED_Operation *op)
1531 {
1532   GNUNET_TESTBED_operation_queue_insert_
1533       (h->opq_parallel_overlay_connect_operations, op);
1534 }
1535
1536
1537 /**
1538  * Handler for GNUNET_MESSAGE_TYPE_TESTBED_ADDHOSTCONFIRM message from
1539  * controller (testbed service)
1540  *
1541  * @param c the controller handler
1542  * @param msg message received
1543  * @return GNUNET_YES if we can continue receiving from service; GNUNET_NO if
1544  *           not
1545  */
1546 int
1547 GNUNET_TESTBED_host_handle_addhostconfirm_ (struct GNUNET_TESTBED_Controller *c,
1548                                             const struct
1549                                             GNUNET_TESTBED_HostConfirmedMessage
1550                                             *msg)
1551 {
1552   struct GNUNET_TESTBED_HostRegistrationHandle *rh;
1553   char *emsg;
1554   uint16_t msg_size;
1555
1556   rh = c->rh;
1557   if (NULL == rh)
1558   {
1559     return GNUNET_OK;
1560   }
1561   if (GNUNET_TESTBED_host_get_id_ (rh->host) != ntohl (msg->host_id))
1562   {
1563     LOG_DEBUG ("Mismatch in host id's %u, %u of host confirm msg\n",
1564                GNUNET_TESTBED_host_get_id_ (rh->host), ntohl (msg->host_id));
1565     return GNUNET_OK;
1566   }
1567   c->rh = NULL;
1568   msg_size = ntohs (msg->header.size);
1569   if (sizeof (struct GNUNET_TESTBED_HostConfirmedMessage) == msg_size)
1570   {
1571     LOG_DEBUG ("Host %u successfully registered\n", ntohl (msg->host_id));
1572     GNUNET_TESTBED_mark_host_registered_at_ (rh->host, c);
1573     rh->cc (rh->cc_cls, NULL);
1574     GNUNET_free (rh);
1575     return GNUNET_OK;
1576   }
1577   /* We have an error message */
1578   emsg = (char *) &msg[1];
1579   if ('\0' !=
1580       emsg[msg_size - sizeof (struct GNUNET_TESTBED_HostConfirmedMessage)])
1581   {
1582     GNUNET_break (0);
1583     GNUNET_free (rh);
1584     return GNUNET_NO;
1585   }
1586   LOG (GNUNET_ERROR_TYPE_ERROR, _("Adding host %u failed with error: %s\n"),
1587        ntohl (msg->host_id), emsg);
1588   rh->cc (rh->cc_cls, emsg);
1589   GNUNET_free (rh);
1590   return GNUNET_OK;
1591 }
1592
1593
1594 /**
1595  * Resolves the hostname of the host to an ip address
1596  *
1597  * @param host the host whose hostname is to be resolved
1598  */
1599 void
1600 GNUNET_TESTBED_host_resolve_ (struct GNUNET_TESTBED_Host *host)
1601 {
1602   char *hostname;
1603
1604   hostname = (char *) host->hostname;
1605   host->hostname = simple_resolve (hostname);
1606   if (NULL == host->hostname)
1607   {
1608     GNUNET_break (0);
1609     host->hostname = hostname;
1610     return;
1611   }
1612   GNUNET_free (hostname);
1613   host->hostname = GNUNET_strdup (host->hostname);
1614 }
1615
1616 /* end of testbed_api_hosts.c */