src/testing/testing.c

   1 /*
   2       This file is part of GNUnet
   3       (C) 2008, 2009, 2012 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 testing/testing.c
  23  * @brief convenience API for writing testcases for GNUnet
  24  *        Many testcases need to start and stop a peer/service
  25  *        and this library is supposed to make that easier
  26  *        for TESTCASES.  Normal programs should always
  27  *        use functions from gnunet_{util,arm}_lib.h.  This API is
  28  *        ONLY for writing testcases (or internal use of the testbed).
  29  * @author Christian Grothoff
  30  *
  31  */
  32 #include "platform.h"
  33 #include "gnunet_util_lib.h"
  34 #include "gnunet_testing_lib-new.h"
  35
  36 #define LOG(kind,...)                                           \
  37   GNUNET_log_from (kind, "gnunettestingnew", __VA_ARGS__)
  38
  39 /**
  40  * Size of a hostkey when written to a file
  41  */
  42 #define HOSTKEYFILESIZE 914
  43
  44 /**
  45  * Lowest port used for GNUnet testing.  Should be high enough to not
  46  * conflict with other applications running on the hosts but be low
  47  * enough to not conflict with client-ports (typically starting around
  48  * 32k).
  49  */
  50 #define LOW_PORT 12000
  51
  52 /**
  53  * Highest port used for GNUnet testing.  Should be low enough to not
  54  * conflict with the port range for "local" ports (client apps; see
  55  * /proc/sys/net/ipv4/ip_local_port_range on Linux for example).
  56  */
  57 #define HIGH_PORT 56000
  58
  59
  60 /**
  61  * Handle for a system on which GNUnet peers are executed;
  62  * a system is used for reserving unique paths and ports.
  63  */
  64 struct GNUNET_TESTING_System
  65 {
  66   /**
  67    * Prefix (i.e. "/tmp/gnunet-testing/") we prepend to each
  68    * SERVICEHOME.    */
  69   char *tmppath;
  70
  71   /**
  72    * The hostname of the controller
  73    */
  74   char *controller;
  75
  76   /**
  77    * Hostkeys data, contains "HOSTKEYFILESIZE * total_hostkeys" bytes.
  78    */
  79   char *hostkeys_data;
  80
  81   /**
  82    * memory map for 'hostkeys_data'.
  83    */
  84   struct GNUNET_DISK_MapHandle *map;
  85
  86   /**
  87    * File descriptor for the map.
  88    */
  89   struct GNUNET_DISK_FileHandle *map_fd;
  90
  91   /**
  92    * Bitmap where each TCP port that has already been reserved for
  93    * some GNUnet peer is recorded.  Note that we additionally need to
  94    * test if a port is already in use by non-GNUnet components before
  95    * assigning it to a peer/service.  If we detect that a port is
  96    * already in use, we also mark it in this bitmap.  So all the bits
  97    * that are zero merely indicate ports that MIGHT be available for
  98    * peers.
  99    */
 100   uint32_t reserved_tcp_ports[65536 / 32];
 101
 102   /**
 103    * Bitmap where each UDP port that has already been reserved for
 104    * some GNUnet peer is recorded.  Note that we additionally need to
 105    * test if a port is already in use by non-GNUnet components before
 106    * assigning it to a peer/service.  If we detect that a port is
 107    * already in use, we also mark it in this bitmap.  So all the bits
 108    * that are zero merely indicate ports that MIGHT be available for
 109    * peers.
 110    */
 111   uint32_t reserved_udp_ports[65536 / 32];
 112
 113   /**
 114    * Counter we use to make service home paths unique on this system;
 115    * the full path consists of the tmppath and this number.  Each
 116    * UNIXPATH for a peer is also modified to include the respective
 117    * path counter to ensure uniqueness.  This field is incremented
 118    * by one for each configured peer.  Even if peers are destroyed,
 119    * we never re-use path counters.
 120    */
 121   uint32_t path_counter;
 122
 123   /**
 124    * The number of hostkeys
 125    */
 126   uint32_t total_hostkeys;
 127 };
 128
 129
 130 /**
 131  * Handle for a GNUnet peer controlled by testing.
 132  */
 133 struct GNUNET_TESTING_Peer
 134 {
 135
 136   /**
 137    * Path to the configuration file for this peer.
 138    */
 139   char *cfgfile;
 140
 141   /**
 142    * Binary to be executed during 'GNUNET_TESTING_peer_start'.
 143    * Typically 'gnunet-service-arm' (but can be set to a
 144    * specific service by 'GNUNET_TESTING_service_run' if
 145    * necessary).
 146    */
 147   char *main_binary;
 148
 149   /**
 150    * Handle to the running binary of the service, NULL if the
 151    * peer/service is currently not running.
 152    */
 153   struct GNUNET_OS_Process *main_process;
 154 };
 155
 156
 157 /**
 158  * Testing includes a number of pre-created hostkeys for faster peer
 159  * startup. This function loads such keys into memory from a file.
 160  *
 161  * @param system the testing system handle
 162  * @return GNUNET_OK on success; GNUNET_SYSERR on error
 163  */
 164 static int
 165 hostkeys_load (struct GNUNET_TESTING_System *system)
 166 {
 167   uint64_t fs;
 168   char *data_dir;
 169   char *filename;
 170
 171   GNUNET_assert (NULL == system->hostkeys_data);
 172   data_dir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_DATADIR);
 173   GNUNET_asprintf (&filename, "%s/testing_hostkeys.dat", data_dir);
 174   GNUNET_free (data_dir);
 175
 176   if (GNUNET_YES != GNUNET_DISK_file_test (filename))
 177   {
 178     LOG (GNUNET_ERROR_TYPE_ERROR,
 179          _("Hostkeys file not found: %s\n"), filename);
 180     GNUNET_free (filename);
 181     return GNUNET_SYSERR;
 182   }
 183   /* Check hostkey file size, read entire thing into memory */
 184   if (GNUNET_OK !=
 185       GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
 186     fs = 0;
 187   if (0 == fs)
 188   {
 189     GNUNET_free (filename);
 190     return GNUNET_SYSERR;       /* File is empty */
 191   }
 192   if (0 != (fs % HOSTKEYFILESIZE))
 193   {
 194     LOG (GNUNET_ERROR_TYPE_ERROR,
 195          _("Incorrect hostkey file format: %s\n"), filename);
 196     GNUNET_free (filename);
 197     return GNUNET_SYSERR;
 198   }
 199   system->map_fd = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ,
 200                                          GNUNET_DISK_PERM_NONE);
 201   if (NULL == system->map_fd)
 202   {
 203     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", filename);
 204     GNUNET_free (filename);
 205     return GNUNET_SYSERR;
 206   }
 207   system->total_hostkeys = fs / HOSTKEYFILESIZE;
 208   system->hostkeys_data = GNUNET_DISK_file_map (system->map_fd,
 209                                                 &system->map,
 210                                                 GNUNET_DISK_MAP_TYPE_READ,
 211                                                 fs);
 212   GNUNET_free (filename);
 213   return GNUNET_OK;
 214 }
 215
 216
 217 /**
 218  * Function to remove the loaded hostkeys
 219  *
 220  * @param system the testing system handle
 221  */
 222 static void
 223 hostkeys_unload (struct GNUNET_TESTING_System *system)
 224 {
 225   GNUNET_break (NULL != system->hostkeys_data);
 226   system->hostkeys_data = NULL;
 227   GNUNET_DISK_file_unmap (system->map);
 228   system->map = NULL;
 229   GNUNET_DISK_file_close (system->map_fd);
 230   system->map_fd = NULL;
 231   system->hostkeys_data = NULL;
 232   system->total_hostkeys = 0;
 233 }
 234
 235
 236 /**
 237  * Create a system handle.  There must only be one system
 238  * handle per operating system.
 239  *
 240  * @param testdir only the directory name without any path. This is used for
 241  *          all service homes; the directory will be created in a temporary
 242  *          location depending on the underlying OS
 243  *
 244  * @param controller hostname of the controlling host,
 245  *        service configurations are modified to allow
 246  *        control connections from this host; can be NULL
 247  * @return handle to this system, NULL on error
 248  */
 249 struct GNUNET_TESTING_System *
 250 GNUNET_TESTING_system_create (const char *testdir,
 251                               const char *controller)
 252 {
 253   struct GNUNET_TESTING_System *system;
 254
 255   GNUNET_assert (NULL != testdir);
 256   system = GNUNET_malloc (sizeof (struct GNUNET_TESTING_System));
 257   system->tmppath = GNUNET_DISK_mkdtemp (testdir);
 258   if (NULL == system->tmppath)
 259   {
 260     GNUNET_free (system);
 261     return NULL;
 262   }
 263   if (NULL != controller)
 264     system->controller = GNUNET_strdup (controller);
 265   if (GNUNET_OK != hostkeys_load (system))
 266   {
 267     GNUNET_TESTING_system_destroy (system, GNUNET_YES);
 268     return NULL;
 269   }
 270   return system;
 271 }
 272
 273
 274 /**
 275  * Free system resources.
 276  *
 277  * @param system system to be freed
 278  * @param remove_paths should the 'testdir' and all subdirectories
 279  *        be removed (clean up on shutdown)?
 280  */
 281 void
 282 GNUNET_TESTING_system_destroy (struct GNUNET_TESTING_System *system,
 283                                int remove_paths)
 284 {
 285   if (NULL != system->hostkeys_data)
 286     hostkeys_unload (system);
 287   if (GNUNET_YES == remove_paths)
 288     GNUNET_DISK_directory_remove (system->tmppath);
 289   GNUNET_free (system->tmppath);
 290   GNUNET_free_non_null (system->controller);
 291   GNUNET_free (system);
 292 }
 293
 294
 295 /**
 296  * Reserve a TCP or UDP port for a peer.
 297  *
 298  * @param system system to use for reservation tracking
 299  * @param is_tcp GNUNET_YES for TCP ports, GNUNET_NO for UDP
 300  * @return 0 if no free port was available
 301  */
 302 uint16_t
 303 GNUNET_TESTING_reserve_port (struct GNUNET_TESTING_System *system,
 304                              int is_tcp)
 305 {
 306   struct GNUNET_NETWORK_Handle *socket;
 307   struct addrinfo hint;
 308   struct addrinfo *ret;
 309   uint32_t *port_buckets;
 310   char *open_port_str;
 311   int bind_status;
 312   uint32_t xor_image;
 313   uint16_t index;
 314   uint16_t open_port;
 315   uint16_t pos;
 316
 317   /*
 318   FIXME: Instead of using getaddrinfo we should try to determine the port
 319          status by the following heurestics.
 320
 321          On systems which support both IPv4 and IPv6, only ports open on both
 322          address families are considered open.
 323          On system with either IPv4 or IPv6. A port is considered open if it's
 324          open in the respective address family
 325   */
 326   hint.ai_family = AF_UNSPEC;   /* IPv4 and IPv6 */
 327   hint.ai_socktype = (GNUNET_YES == is_tcp)? SOCK_STREAM : SOCK_DGRAM;
 328   hint.ai_protocol = 0;
 329   hint.ai_addrlen = 0;
 330   hint.ai_addr = NULL;
 331   hint.ai_canonname = NULL;
 332   hint.ai_next = NULL;
 333   hint.ai_flags = AI_PASSIVE | AI_NUMERICSERV;  /* Wild card address */
 334   port_buckets = (GNUNET_YES == is_tcp) ?
 335     system->reserved_tcp_ports : system->reserved_udp_ports;
 336   for (index = (LOW_PORT / 32) + 1; index < (HIGH_PORT / 32); index++)
 337   {
 338     xor_image = (UINT32_MAX ^ port_buckets[index]);
 339     if (0 == xor_image)        /* Ports in the bucket are full */
 340       continue;
 341     pos = 0;
 342     while (pos < 32)
 343     {
 344       if (0 == ((xor_image >> pos) & 1U))
 345       {
 346         pos++;
 347         continue;
 348       }
 349       open_port = (index * 32) + pos;
 350       GNUNET_asprintf (&open_port_str, "%u", (unsigned int) open_port);
 351       ret = NULL;
 352       GNUNET_assert (0 == getaddrinfo (NULL, open_port_str, &hint, &ret));
 353       GNUNET_free (open_port_str);
 354       socket = GNUNET_NETWORK_socket_create (ret->ai_family,
 355                                              (GNUNET_YES == is_tcp) ?
 356                                              SOCK_STREAM : SOCK_DGRAM,
 357                                              0);
 358       GNUNET_assert (NULL != socket);
 359       bind_status = GNUNET_NETWORK_socket_bind (socket,
 360                                                 ret->ai_addr,
 361                                                 ret->ai_addrlen);
 362       freeaddrinfo (ret);
 363       GNUNET_NETWORK_socket_close (socket);
 364       socket = NULL;
 365       port_buckets[index] |= (1U << pos); /* Set the port bit */
 366       if (GNUNET_OK == bind_status)
 367       {
 368         LOG (GNUNET_ERROR_TYPE_DEBUG,
 369              "Found a free port %u\n", (unsigned int) open_port);
 370         return open_port;
 371       }
 372       pos++;
 373     }
 374   }
 375   return 0;
 376 }
 377
 378
 379 /**
 380  * Release reservation of a TCP or UDP port for a peer
 381  * (used during GNUNET_TESTING_peer_destroy).
 382  *
 383  * @param system system to use for reservation tracking
 384  * @param is_tcp GNUNET_YES for TCP ports, GNUNET_NO for UDP
 385  * @param port reserved port to release
 386  */
 387 void
 388 GNUNET_TESTING_release_port (struct GNUNET_TESTING_System *system,
 389                              int is_tcp,
 390                              uint16_t port)
 391 {
 392   uint32_t *port_buckets;
 393   uint16_t bucket;
 394   uint16_t pos;
 395
 396   port_buckets = (GNUNET_YES == is_tcp) ?
 397     system->reserved_tcp_ports : system->reserved_udp_ports;
 398   bucket = port / 32;
 399   pos = port % 32;
 400   LOG (GNUNET_ERROR_TYPE_DEBUG, "Releasing port %u\n", port);
 401   if (0 == (port_buckets[bucket] & (1U << pos)))
 402   {
 403     GNUNET_break(0); /* Port was not reserved by us using reserve_port() */
 404     return;
 405   }
 406   port_buckets[bucket] &= ~(1U << pos);
 407 }
 408
 409
 410 /**
 411  * Reserve a SERVICEHOME path for a peer.
 412  *
 413  * @param system system to use for reservation tracking
 414  * @return NULL on error, otherwise fresh unique path to use
 415  *         as the servicehome for the peer; must be freed by the caller
 416  */
 417 // static
 418 char *
 419 reserve_path (struct GNUNET_TESTING_System *system)
 420 {
 421   char *reserved_path;
 422
 423   GNUNET_asprintf (&reserved_path,
 424                    "%s/%u", system->tmppath, system->path_counter++);
 425   return reserved_path;
 426 }
 427
 428
 429 /**
 430  * Testing includes a number of pre-created hostkeys for
 431  * faster peer startup.  This function can be used to
 432  * access the n-th key of those pre-created hostkeys; note
 433  * that these keys are ONLY useful for testing and not
 434  * secure as the private keys are part of the public
 435  * GNUnet source code.
 436  *
 437  * This is primarily a helper function used internally
 438  * by 'GNUNET_TESTING_peer_configure'.
 439  *
 440  * @param system the testing system handle
 441  * @param key_number desired pre-created hostkey to obtain
 442  * @param id set to the peer's identity (hash of the public
 443  *        key; if NULL, GNUNET_SYSERR is returned immediately
 444  * @return NULL on error (not enough keys)
 445  */
 446 struct GNUNET_CRYPTO_RsaPrivateKey *
 447 GNUNET_TESTING_hostkey_get (const struct GNUNET_TESTING_System *system,
 448                             uint32_t key_number,
 449                             struct GNUNET_PeerIdentity *id)
 450 {
 451   struct GNUNET_CRYPTO_RsaPrivateKey *private_key;
 452   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded public_key;
 453
 454   if ((NULL == id) || (NULL == system->hostkeys_data))
 455     return NULL;
 456   if (key_number >= system->total_hostkeys)
 457   {
 458     LOG (GNUNET_ERROR_TYPE_ERROR,
 459          _("Key number %u does not exist\n"), key_number);
 460     return NULL;
 461   }
 462   private_key = GNUNET_CRYPTO_rsa_decode_key (system->hostkeys_data +
 463                                               (key_number * HOSTKEYFILESIZE),
 464                                               HOSTKEYFILESIZE);
 465   if (NULL == private_key)
 466   {
 467     LOG (GNUNET_ERROR_TYPE_ERROR,
 468          _("Error while decoding key %u\n"), key_number);
 469     return NULL;
 470   }
 471   GNUNET_CRYPTO_rsa_key_get_public (private_key, &public_key);
 472   GNUNET_CRYPTO_hash (&public_key,
 473                       sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
 474                       &(id->hashPubKey));
 475   return private_key;
 476 }
 477
 478
 479 /**
 480  * Structure for holding data to build new configurations from a configuration
 481  * template
 482  */
 483 struct UpdateContext
 484 {
 485   /**
 486    * The system for which we are building configurations
 487    */
 488   struct GNUNET_TESTING_System *system;
 489
 490   /**
 491    * The configuration we are building
 492    */
 493   struct GNUNET_CONFIGURATION_Handle *cfg;
 494
 495   /**
 496    * The customized service home path for this peer
 497    */
 498   char *service_home;
 499
 500   /**
 501    * build status - to signal error while building a configuration
 502    */
 503   int status;
 504 };
 505
 506
 507 /**
 508  * Function to iterate over options.  Copies
 509  * the options to the target configuration,
 510  * updating PORT values as needed.
 511  *
 512  * @param cls the UpdateContext
 513  * @param section name of the section
 514  * @param option name of the option
 515  * @param value value of the option
 516  */
 517 static void
 518 update_config (void *cls, const char *section, const char *option,
 519                const char *value)
 520 {
 521   struct UpdateContext *uc = cls;
 522   unsigned int ival;
 523   char cval[12];
 524   char uval[128];
 525   char *single_variable;
 526   char *per_host_variable;
 527   unsigned long long num_per_host;
 528   uint16_t new_port;
 529
 530   if (GNUNET_OK != uc->status)
 531     return;
 532   if (! ((0 == strcmp (option, "PORT"))
 533          || (0 == strcmp (option, "UNIXPATH"))
 534          || (0 == strcmp (option, "HOSTNAME"))))
 535     return;
 536   GNUNET_asprintf (&single_variable, "single_%s_per_host", section);
 537   GNUNET_asprintf (&per_host_variable, "num_%s_per_host", section);
 538   if ((0 == strcmp (option, "PORT")) && (1 == SSCANF (value, "%u", &ival)))
 539   {
 540     if ((ival != 0) &&
 541         (GNUNET_YES !=
 542          GNUNET_CONFIGURATION_get_value_yesno (uc->cfg, "testing",
 543                                                single_variable)))
 544     {
 545       /* FIXME: What about UDP? */
 546       new_port = GNUNET_TESTING_reserve_port (uc->system, GNUNET_YES);
 547       if (0 == new_port)
 548       {
 549         uc->status = GNUNET_SYSERR;
 550         return;
 551       }
 552       GNUNET_snprintf (cval, sizeof (cval), "%u", new_port);
 553       value = cval;
 554     }
 555     else if ((ival != 0) &&
 556              (GNUNET_YES ==
 557               GNUNET_CONFIGURATION_get_value_yesno (uc->cfg, "testing",
 558                                                     single_variable)) &&
 559              GNUNET_CONFIGURATION_get_value_number (uc->cfg, "testing",
 560                                                     per_host_variable,
 561                                                     &num_per_host))
 562     {
 563       /* GNUNET_snprintf (cval, sizeof (cval), "%u", */
 564       /*                  ival + ctx->fdnum % num_per_host); */
 565       /* value = cval; */
 566       GNUNET_break (0);         /* FIXME */
 567     }
 568   }
 569   if (0 == strcmp (option, "UNIXPATH"))
 570   {
 571     if (GNUNET_YES !=
 572         GNUNET_CONFIGURATION_get_value_yesno (uc->cfg, "testing",
 573                                               single_variable))
 574     {
 575       GNUNET_snprintf (uval, sizeof (uval), "%s/%s.sock",
 576                        uc->service_home, section);
 577       value = uval;
 578     }
 579     else if ((GNUNET_YES ==
 580               GNUNET_CONFIGURATION_get_value_number (uc->cfg, "testing",
 581                                                      per_host_variable,
 582                                                      &num_per_host)) &&
 583              (num_per_host > 0))
 584     {
 585       GNUNET_break(0);          /* FIXME */
 586     }
 587   }
 588   if ((0 == strcmp (option, "HOSTNAME")) && (NULL != uc->system->controller))
 589   {
 590     value = uc->system->controller;
 591   }
 592   GNUNET_free (single_variable);
 593   GNUNET_free (per_host_variable);
 594   GNUNET_CONFIGURATION_set_value_string (uc->cfg, section, option, value);
 595 }
 596
 597
 598 /**
 599  * Section iterator to set ACCEPT_FROM in all sections
 600  *
 601  * @param cls the UpdateContext
 602  * @param section name of the section
 603  */
 604 static void
 605 update_config_sections (void *cls,
 606                         const char *section)
 607 {
 608   struct UpdateContext *uc = cls;
 609   char *orig_allowed_hosts;
 610   char *allowed_hosts;
 611
 612   if (GNUNET_OK !=
 613       GNUNET_CONFIGURATION_get_value_string (uc->cfg, section, "ACCEPT_FROM",
 614                                              &orig_allowed_hosts))
 615   {
 616     orig_allowed_hosts = GNUNET_strdup ("127.0.0.1;");
 617   }
 618   if (NULL == uc->system->controller)
 619     allowed_hosts = GNUNET_strdup (orig_allowed_hosts);
 620   else
 621     GNUNET_asprintf (&allowed_hosts, "%s%s;", orig_allowed_hosts,
 622                      uc->system->controller);
 623   GNUNET_free (orig_allowed_hosts);
 624   GNUNET_CONFIGURATION_set_value_string (uc->cfg, section, "ACCEPT_FROM",
 625                                          allowed_hosts);
 626   GNUNET_free (allowed_hosts);
 627 }
 628
 629
 630 /**
 631  * Create a new configuration using the given configuration
 632  * as a template; ports and paths will be modified to select
 633  * available ports on the local system.  If we run
 634  * out of "*port" numbers, return SYSERR.
 635  *
 636  * This is primarily a helper function used internally
 637  * by 'GNUNET_TESTING_peer_configure'.
 638  *
 639  * @param system system to use to coordinate resource usage
 640  * @param cfg template configuration to update
 641  * @return GNUNET_OK on success, GNUNET_SYSERR on error - the configuration will
 642  *           be incomplete and should not be used there upon
 643  */
 644 int
 645 GNUNET_TESTING_configuration_create (struct GNUNET_TESTING_System *system,
 646                                      struct GNUNET_CONFIGURATION_Handle *cfg)
 647 {
 648   struct UpdateContext uc;
 649   char *default_config;
 650
 651   uc.system = system;
 652   uc.cfg = cfg;
 653   uc.status = GNUNET_OK;
 654   GNUNET_asprintf (&uc.service_home, "%s/%u", system->tmppath,
 655                    system->path_counter++);
 656   GNUNET_asprintf (&default_config, "%s/config", uc.service_home);
 657   GNUNET_CONFIGURATION_set_value_string (cfg, "PATHS", "DEFAULTCONFIG",
 658                                          default_config);
 659   GNUNET_free (default_config);
 660   GNUNET_CONFIGURATION_set_value_string (cfg, "PATHS", "SERVICEHOME",
 661                                          uc.service_home);
 662   /* make PORTs and UNIXPATHs unique */
 663   GNUNET_CONFIGURATION_iterate (cfg, &update_config, &uc);
 664   /* allow connections to services from system controller host */
 665   GNUNET_CONFIGURATION_iterate_sections (cfg, &update_config_sections, &uc);
 666   /* enable loopback-based connections between peers */
 667   GNUNET_CONFIGURATION_set_value_string (cfg,
 668                                          "nat",
 669                                          "USE_LOCALADDR", "YES");
 670   GNUNET_free (uc.service_home);
 671   return uc.status;
 672 }
 673
 674
 675 /**
 676  * Configure a GNUnet peer.  GNUnet must be installed on the local
 677  * system and available in the PATH.
 678  *
 679  * @param system system to use to coordinate resource usage
 680  * @param cfg configuration to use; will be UPDATED (to reflect needed
 681  *            changes in port numbers and paths)
 682  * @param key_number number of the hostkey to use for the peer
 683  * @param id identifier for the daemon, will be set, can be NULL
 684  * @param emsg set to error message (set to NULL on success), can be NULL
 685  * @return handle to the peer, NULL on error
 686  */
 687 struct GNUNET_TESTING_Peer *
 688 GNUNET_TESTING_peer_configure (struct GNUNET_TESTING_System *system,
 689                                struct GNUNET_CONFIGURATION_Handle *cfg,
 690                                uint32_t key_number,
 691                                struct GNUNET_PeerIdentity *id,
 692                                char **emsg)
 693 {
 694   struct GNUNET_TESTING_Peer *peer;
 695   struct GNUNET_DISK_FileHandle *fd;
 696   char *service_home;
 697   char hostkey_filename[128];
 698   char *config_filename;
 699   char *emsg_;
 700   struct GNUNET_CRYPTO_RsaPrivateKey *pk;
 701
 702   if (NULL != emsg)
 703     *emsg = NULL;
 704   if (GNUNET_OK != GNUNET_TESTING_configuration_create (system, cfg))
 705   {
 706     GNUNET_asprintf (&emsg_,
 707                        _("Failed to create configuration for peer (not enough free ports?)\n"));
 708     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s", *emsg_);
 709     if (NULL != emsg)
 710       *emsg = emsg_;
 711     else
 712       GNUNET_free (emsg_);
 713     return NULL;
 714   }
 715   if (key_number >= system->total_hostkeys)
 716   {
 717     GNUNET_asprintf (&emsg_,
 718                      _("You attempted to create a testbed with more than %u hosts.  Please precompute more hostkeys first.\n"),
 719                      (unsigned int) system->total_hostkeys);
 720     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s", emsg_);
 721     if (NULL != emsg)
 722       *emsg = emsg_;
 723     else
 724       GNUNET_free (emsg_);
 725     return NULL;
 726   }
 727   pk = NULL;
 728   if ((NULL != id) &&
 729       (NULL == (pk = GNUNET_TESTING_hostkey_get (system, key_number, id))))
 730   {
 731     GNUNET_asprintf (&emsg_,
 732                      _("Failed to initialize hostkey for peer %u\n"),
 733                      (unsigned int) key_number);
 734     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s", *emsg_);
 735     if (NULL != emsg)
 736       *emsg = emsg_;
 737     else
 738       GNUNET_free (emsg_);
 739     return NULL;
 740   }
 741   if (NULL != pk)
 742     GNUNET_CRYPTO_rsa_key_free (pk);
 743   GNUNET_assert (GNUNET_OK ==
 744                  GNUNET_CONFIGURATION_get_value_string (cfg, "PATHS",
 745                                                         "SERVICEHOME",
 746                                                         &service_home));
 747   GNUNET_snprintf (hostkey_filename, sizeof (hostkey_filename), "%s/.hostkey",
 748                    service_home);
 749   GNUNET_free (service_home);
 750   fd = GNUNET_DISK_file_open (hostkey_filename,
 751                               GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_WRITE,
 752                               GNUNET_DISK_PERM_USER_READ
 753                               | GNUNET_DISK_PERM_USER_WRITE);
 754   if (NULL == fd)
 755   {
 756     GNUNET_break (0);
 757     return NULL;
 758   }
 759   if (HOSTKEYFILESIZE !=
 760       GNUNET_DISK_file_write (fd, system->hostkeys_data
 761                               + (key_number * HOSTKEYFILESIZE),
 762                               HOSTKEYFILESIZE))
 763   {
 764     GNUNET_asprintf (&emsg_,
 765                      _("Failed to write hostkey file for peer %u: %s\n"),
 766                      (unsigned int) key_number,
 767                      STRERROR (errno));
 768     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s", *emsg_);
 769     if (NULL != emsg)
 770       *emsg = emsg_;
 771     else
 772       GNUNET_free (emsg_);
 773     GNUNET_DISK_file_close (fd);
 774     return NULL;
 775   }
 776   GNUNET_DISK_file_close (fd);
 777   GNUNET_assert (GNUNET_OK ==
 778                  GNUNET_CONFIGURATION_get_value_string
 779                  (cfg, "PATHS", "DEFAULTCONFIG", &config_filename));
 780   if (GNUNET_OK != GNUNET_CONFIGURATION_write (cfg, config_filename))
 781   {
 782     GNUNET_asprintf (&emsg_,
 783                      _("Failed to write configuration file `%s' for peer %u: %s\n"),
 784                      config_filename,
 785                      (unsigned int) key_number,
 786                      STRERROR (errno));
 787     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s", *emsg_);
 788     if (NULL != emsg)
 789       *emsg = emsg_;
 790     else
 791       GNUNET_free (emsg_);
 792     GNUNET_free (config_filename);
 793     return NULL;
 794   }
 795   peer = GNUNET_malloc (sizeof (struct GNUNET_TESTING_Peer));
 796   peer->cfgfile = config_filename; /* Free in peer_destroy */
 797   peer->main_binary = GNUNET_strdup ("gnunet-service-arm");
 798   return peer;
 799 }
 800
 801
 802 /**
 803  * Start the peer.
 804  *
 805  * @param peer peer to start
 806  * @return GNUNET_OK on success, GNUNET_SYSERR on error (i.e. peer already running)
 807  */
 808 int
 809 GNUNET_TESTING_peer_start (struct GNUNET_TESTING_Peer *peer)
 810 {
 811   if (NULL != peer->main_process)
 812   {
 813     GNUNET_break (0);
 814     return GNUNET_SYSERR;
 815   }
 816   GNUNET_assert (NULL != peer->cfgfile);
 817   peer->main_process = GNUNET_OS_start_process (GNUNET_YES, NULL, NULL,
 818                                                 peer->main_binary,
 819                                                 peer->main_binary,
 820                                                 "-c",
 821                                                 peer->cfgfile,
 822                                                 NULL);
 823   if (NULL == peer->main_process)
 824   {
 825     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 826                 _("Failed to start `%s': %s\n"),
 827                 peer->main_binary,
 828                 STRERROR (errno));
 829     return GNUNET_SYSERR;
 830   }
 831   return GNUNET_OK;
 832 }
 833
 834
 835 /**
 836  * Stop the peer.
 837  *
 838  * @param peer peer to stop
 839  * @return GNUNET_OK on success, GNUNET_SYSERR on error (i.e. peer not running)
 840  */
 841 int
 842 GNUNET_TESTING_peer_stop (struct GNUNET_TESTING_Peer *peer)
 843 {
 844   if (NULL == peer->main_process)
 845   {
 846     GNUNET_break (0);
 847     return GNUNET_SYSERR;
 848   }
 849   (void) GNUNET_OS_process_kill (peer->main_process, SIGTERM);
 850   GNUNET_assert (GNUNET_OK == GNUNET_OS_process_wait (peer->main_process));
 851   GNUNET_OS_process_destroy (peer->main_process);
 852   peer->main_process = NULL;
 853   return GNUNET_OK;
 854 }
 855
 856
 857 /**
 858  * Destroy the peer.  Releases resources locked during peer configuration.
 859  * If the peer is still running, it will be stopped AND a warning will be
 860  * printed (users of the API should stop the peer explicitly first).
 861  *
 862  * @param peer peer to destroy
 863  */
 864 void
 865 GNUNET_TESTING_peer_destroy (struct GNUNET_TESTING_Peer *peer)
 866 {
 867   if (NULL != peer->main_process)
 868   {
 869     GNUNET_break (0);
 870     GNUNET_TESTING_peer_stop (peer);
 871   }
 872   GNUNET_free (peer->cfgfile);
 873   GNUNET_free (peer->main_binary);
 874   GNUNET_free (peer);
 875 }
 876
 877
 878 /**
 879  * Start a single peer and run a test using the testing library.
 880  * Starts a peer using the given configuration and then invokes the
 881  * given callback.  This function ALSO initializes the scheduler loop
 882  * and should thus be called directly from "main".  The testcase
 883  * should self-terminate by invoking 'GNUNET_SCHEDULER_shutdown'.
 884  *
 885  * @param testdir only the directory name without any path. This is used for
 886  *          all service homes; the directory will be created in a temporary
 887  *          location depending on the underlying OS
 888  * @param cfgfilename name of the configuration file to use;
 889  *         use NULL to only run with defaults
 890  * @param tm main function of the testcase
 891  * @param tm_cls closure for 'tm'
 892  * @return 0 on success, 1 on error
 893  */
 894 int
 895 GNUNET_TESTING_peer_run (const char *testdir,
 896                          const char *cfgfilename,
 897                          GNUNET_TESTING_TestMain tm,
 898                          void *tm_cls)
 899 {
 900   return GNUNET_TESTING_service_run (testdir, "arm",
 901                                      cfgfilename, tm, tm_cls);
 902 }
 903
 904
 905 /**
 906  * Structure for holding service data
 907  */
 908 struct ServiceContext
 909 {
 910   /**
 911    * The configuration of the peer in which the service is run
 912    */
 913   const struct GNUNET_CONFIGURATION_Handle *cfg;
 914
 915   /**
 916    * Callback to signal service startup
 917    */
 918   GNUNET_TESTING_TestMain tm;
 919
 920   /**
 921    * Closure for the above callback
 922    */
 923   void *tm_cls;
 924 };
 925
 926
 927 /**
 928  * Structure for holding service data
 929  */
 930 struct RestartableServiceContext
 931 {
 932   /**
 933    * The configuration of the peer in which the service is run
 934    */
 935   const struct GNUNET_CONFIGURATION_Handle *cfg;
 936
 937   /**
 938    * Callback to signal service startup
 939    */
 940   GNUNET_TESTING_RestartableTestMain tm;
 941
 942   /**
 943    * The peer in which the service is run.
 944    */
 945   const struct GNUNET_TESTING_Peer *peer;
 946
 947   /**
 948    * Closure for the above callback
 949    */
 950   void *tm_cls;
 951 };
 952
 953
 954 /**
 955  * Callback to be called when SCHEDULER has been started
 956  *
 957  * @param cls the ServiceContext
 958  * @param tc the TaskContext
 959  */
 960 static void
 961 service_run_main (void *cls,
 962                   const struct GNUNET_SCHEDULER_TaskContext *tc)
 963 {
 964   struct ServiceContext *sc = cls;
 965
 966   sc->tm (sc->tm_cls, sc->cfg);
 967 }
 968
 969
 970 /**
 971  * Callback to be called when SCHEDULER has been started
 972  *
 973  * @param cls the ServiceContext
 974  * @param tc the TaskContext
 975  */
 976 static void
 977 service_run_restartable_main (void *cls,
 978                   const struct GNUNET_SCHEDULER_TaskContext *tc)
 979 {
 980   struct RestartableServiceContext *sc = cls;
 981
 982   sc->tm (sc->tm_cls, sc->cfg, sc->peer);
 983 }
 984
 985
 986 /**
 987  * Start a single service (no ARM, except of course if the given
 988  * service name is 'arm') and run a test using the testing library.
 989  * Starts a service using the given configuration and then invokes the
 990  * given callback.  This function ALSO initializes the scheduler loop
 991  * and should thus be called directly from "main".  The testcase
 992  * should self-terminate by invoking 'GNUNET_SCHEDULER_shutdown'.
 993  *
 994  * This function is useful if the testcase is for a single service
 995  * and if that service doesn't itself depend on other services.
 996  *
 997  * @param testdir only the directory name without any path. This is used for
 998  *          all service homes; the directory will be created in a temporary
 999  *          location depending on the underlying OS
1000  * @param service_name name of the service to run
1001  * @param cfgfilename name of the configuration file to use;
1002  *         use NULL to only run with defaults
1003  * @param tm main function of the testcase
1004  * @param tm_cls closure for 'tm'
1005  * @return 0 on success, 1 on error
1006  */
1007 int
1008 GNUNET_TESTING_service_run (const char *testdir,
1009                             const char *service_name,
1010                             const char *cfgfilename,
1011                             GNUNET_TESTING_TestMain tm,
1012                             void *tm_cls)
1013 {
1014   struct ServiceContext sc;
1015   struct GNUNET_TESTING_System *system;
1016   struct GNUNET_TESTING_Peer *peer;
1017   struct GNUNET_CONFIGURATION_Handle *cfg;
1018
1019   GNUNET_log_setup (testdir,
1020                     "WARNING",
1021                     NULL);
1022   system = GNUNET_TESTING_system_create (testdir, "127.0.0.1");
1023   if (NULL == system)
1024     return 1;
1025   cfg = GNUNET_CONFIGURATION_create ();
1026   if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg, cfgfilename))
1027   {
1028     LOG (GNUNET_ERROR_TYPE_ERROR,
1029          _("Failed to load configuration from %s\n"), cfgfilename);
1030     GNUNET_CONFIGURATION_destroy (cfg);
1031     GNUNET_TESTING_system_destroy (system, GNUNET_YES);
1032     return 1;
1033   }
1034   peer = GNUNET_TESTING_peer_configure (system, cfg, 0, NULL, NULL);
1035   if (NULL == peer)
1036   {
1037     GNUNET_CONFIGURATION_destroy (cfg);
1038     hostkeys_unload (system);
1039     GNUNET_TESTING_system_destroy (system, GNUNET_YES);
1040     return 1;
1041   }
1042   GNUNET_free (peer->main_binary);
1043   GNUNET_asprintf (&peer->main_binary, "gnunet-service-%s", service_name);
1044   if (GNUNET_OK != GNUNET_TESTING_peer_start (peer))
1045   {
1046     GNUNET_TESTING_peer_destroy (peer);
1047     GNUNET_CONFIGURATION_destroy (cfg);
1048     GNUNET_TESTING_system_destroy (system, GNUNET_YES);
1049     return 1;
1050   }
1051   sc.cfg = cfg;
1052   sc.tm = tm;
1053   sc.tm_cls = tm_cls;
1054   GNUNET_SCHEDULER_run (&service_run_main, &sc); /* Scheduler loop */
1055   if (GNUNET_OK != GNUNET_TESTING_peer_stop (peer))
1056   {
1057     GNUNET_TESTING_peer_destroy (peer);
1058     GNUNET_CONFIGURATION_destroy (cfg);
1059     GNUNET_TESTING_system_destroy (system, GNUNET_YES);
1060     return 1;
1061   }
1062   GNUNET_TESTING_peer_destroy (peer);
1063   GNUNET_CONFIGURATION_destroy (cfg);
1064   GNUNET_TESTING_system_destroy (system, GNUNET_YES);
1065   return 0;
1066 }
1067
1068
1069
1070 /**
1071  * See GNUNET_TESTING_service_run.
1072  * The only difference is that we handle the GNUNET_TESTING_Peer to
1073  * the RestartableTestMain, so that the peer can be destroyed and re-created
1074  * to simulate failure in tests.
1075  */
1076 int
1077 GNUNET_TESTING_service_run_restartable (const char *testdir,
1078                             const char *service_name,
1079                             const char *cfgfilename,
1080                             GNUNET_TESTING_RestartableTestMain tm,
1081                             void *tm_cls)
1082 {
1083   struct RestartableServiceContext sc;
1084   struct GNUNET_TESTING_System *system;
1085   struct GNUNET_TESTING_Peer *peer;
1086   struct GNUNET_CONFIGURATION_Handle *cfg;
1087
1088   GNUNET_log_setup (testdir,
1089                     "WARNING",
1090                     NULL);
1091   system = GNUNET_TESTING_system_create (testdir, "127.0.0.1");
1092   if (NULL == system)
1093     return 1;
1094   cfg = GNUNET_CONFIGURATION_create ();
1095   if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg, cfgfilename))
1096   {
1097     LOG (GNUNET_ERROR_TYPE_ERROR,
1098          _("Failed to load configuration from %s\n"), cfgfilename);
1099     GNUNET_CONFIGURATION_destroy (cfg);
1100     GNUNET_TESTING_system_destroy (system, GNUNET_YES);
1101     return 1;
1102   }
1103   peer = GNUNET_TESTING_peer_configure (system, cfg, 0, NULL, NULL);
1104   if (NULL == peer)
1105   {
1106     GNUNET_CONFIGURATION_destroy (cfg);
1107     hostkeys_unload (system);
1108     GNUNET_TESTING_system_destroy (system, GNUNET_YES);
1109     return 1;
1110   }
1111   GNUNET_free (peer->main_binary);
1112   GNUNET_asprintf (&peer->main_binary, "gnunet-service-%s", service_name);
1113   if (GNUNET_OK != GNUNET_TESTING_peer_start (peer))
1114   {
1115     GNUNET_TESTING_peer_destroy (peer);
1116     GNUNET_CONFIGURATION_destroy (cfg);
1117     GNUNET_TESTING_system_destroy (system, GNUNET_YES);
1118     return 1;
1119   }
1120   sc.cfg = cfg;
1121   sc.tm = tm;
1122   sc.tm_cls = tm_cls;
1123   sc.peer = peer;
1124   GNUNET_SCHEDULER_run (&service_run_restartable_main, &sc); /* Scheduler loop */
1125   if (GNUNET_OK != GNUNET_TESTING_peer_stop (peer))
1126   {
1127     GNUNET_TESTING_peer_destroy (peer);
1128     GNUNET_CONFIGURATION_destroy (cfg);
1129     GNUNET_TESTING_system_destroy (system, GNUNET_YES);
1130     return 1;
1131   }
1132   GNUNET_TESTING_peer_destroy (peer);
1133   GNUNET_CONFIGURATION_destroy (cfg);
1134   GNUNET_TESTING_system_destroy (system, GNUNET_YES);
1135   return 0;
1136 }
1137
1138
1139 /**
1140  * Sometimes we use the binary name to determine which specific
1141  * test to run.  In those cases, the string after the last "_"
1142  * in 'argv[0]' specifies a string that determines the configuration
1143  * file or plugin to use.
1144  *
1145  * This function returns the respective substring, taking care
1146  * of issues such as binaries ending in '.exe' on W32.
1147  *
1148  * @param argv0 the name of the binary
1149  * @return string between the last '_' and the '.exe' (or the end of the string),
1150  *         NULL if argv0 has no '_'
1151  */
1152 char *
1153 GNUNET_TESTING_get_testname_from_underscore (const char *argv0)
1154 {
1155   size_t slen = strlen (argv0) + 1;
1156   char sbuf[slen];
1157   char *ret;
1158   char *dot;
1159
1160   memcpy (sbuf, argv0, slen);
1161   ret = strrchr (sbuf, '_');
1162   if (NULL == ret)
1163     return NULL;
1164   ret++; /* skip underscore */
1165   dot = strchr (ret, '.');
1166   if (NULL != dot)
1167     *dot = '\0';
1168   return GNUNET_strdup (ret);
1169 }
1170
1171
1172 /* end of testing.c */