2 This file is part of GNUnet
3 (C) 2008, 2009, 2012 Christian Grothoff (and other contributing authors)
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 3, or (at your
8 option) any later version.
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.
22 * @file 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
33 #include "gnunet_util_lib.h"
34 #include "gnunet_testing_lib-new.h"
36 #define LOG(kind,...) \
37 GNUNET_log_from (kind, "gnunettestingnew", __VA_ARGS__)
40 * Size of a hostkey when written to a file
42 #define HOSTKEYFILESIZE 914
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
50 #define LOW_PORT 12000
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).
57 #define HIGH_PORT 56000
61 * Handle for a system on which GNUnet peers are executed;
62 * a system is used for reserving unique paths and ports.
64 struct GNUNET_TESTING_System
67 * Prefix (i.e. "/tmp/gnunet-testing/") we prepend to each
72 * The hostname of the controller
77 * Hostkeys data, contains "HOSTKEYFILESIZE * total_hostkeys" bytes.
82 * memory map for 'hostkeys_data'.
84 struct GNUNET_DISK_MapHandle *map;
87 * File descriptor for the map.
89 struct GNUNET_DISK_FileHandle *map_fd;
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
100 uint32_t reserved_tcp_ports[65536 / 32];
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
111 uint32_t reserved_udp_ports[65536 / 32];
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.
121 uint32_t path_counter;
124 * The number of hostkeys
126 uint32_t total_hostkeys;
131 * Handle for a GNUnet peer controlled by testing.
133 struct GNUNET_TESTING_Peer
137 * Path to the configuration file for this peer.
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
150 * Handle to the running binary of the service, NULL if the
151 * peer/service is currently not running.
153 struct GNUNET_OS_Process *main_process;
158 * Testing includes a number of pre-created hostkeys for faster peer
159 * startup. This function loads such keys into memory from a file.
161 * @param system the testing system handle
162 * @return GNUNET_OK on success; GNUNET_SYSERR on error
165 hostkeys_load (struct GNUNET_TESTING_System *system)
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);
176 if (GNUNET_YES != GNUNET_DISK_file_test (filename))
178 LOG (GNUNET_ERROR_TYPE_ERROR,
179 _("Hostkeys file not found: %s\n"), filename);
180 GNUNET_free (filename);
181 return GNUNET_SYSERR;
183 /* Check hostkey file size, read entire thing into memory */
185 GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
189 GNUNET_free (filename);
190 return GNUNET_SYSERR; /* File is empty */
192 if (0 != (fs % HOSTKEYFILESIZE))
194 LOG (GNUNET_ERROR_TYPE_ERROR,
195 _("Incorrect hostkey file format: %s\n"), filename);
196 GNUNET_free (filename);
197 return GNUNET_SYSERR;
199 system->map_fd = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ,
200 GNUNET_DISK_PERM_NONE);
201 if (NULL == system->map_fd)
203 GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", filename);
204 GNUNET_free (filename);
205 return GNUNET_SYSERR;
207 system->total_hostkeys = fs / HOSTKEYFILESIZE;
208 system->hostkeys_data = GNUNET_DISK_file_map (system->map_fd,
210 GNUNET_DISK_MAP_TYPE_READ,
212 GNUNET_free (filename);
218 * Function to remove the loaded hostkeys
220 * @param system the testing system handle
223 hostkeys_unload (struct GNUNET_TESTING_System *system)
225 GNUNET_break (NULL != system->hostkeys_data);
226 system->hostkeys_data = NULL;
227 GNUNET_DISK_file_unmap (system->map);
229 GNUNET_DISK_file_close (system->map_fd);
230 system->map_fd = NULL;
231 system->hostkeys_data = NULL;
232 system->total_hostkeys = 0;
237 * Create a system handle. There must only be one system
238 * handle per operating system.
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
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
249 struct GNUNET_TESTING_System *
250 GNUNET_TESTING_system_create (const char *testdir,
251 const char *controller)
253 struct GNUNET_TESTING_System *system;
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)
260 GNUNET_free (system);
263 if (NULL != controller)
264 system->controller = GNUNET_strdup (controller);
265 if (GNUNET_OK != hostkeys_load (system))
267 GNUNET_TESTING_system_destroy (system, GNUNET_YES);
275 * Free system resources.
277 * @param system system to be freed
278 * @param remove_paths should the 'testdir' and all subdirectories
279 * be removed (clean up on shutdown)?
282 GNUNET_TESTING_system_destroy (struct GNUNET_TESTING_System *system,
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);
296 * Reserve a TCP or UDP port for a peer.
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
303 GNUNET_TESTING_reserve_port (struct GNUNET_TESTING_System *system,
306 struct GNUNET_NETWORK_Handle *socket;
307 struct addrinfo hint;
308 struct addrinfo *ret;
309 uint32_t *port_buckets;
318 FIXME: Instead of using getaddrinfo we should try to determine the port
319 status by the following heurestics.
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
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;
331 hint.ai_canonname = 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++)
338 xor_image = (UINT32_MAX ^ port_buckets[index]);
339 if (0 == xor_image) /* Ports in the bucket are full */
344 if (0 == ((xor_image >> pos) & 1U))
349 open_port = (index * 32) + pos;
350 GNUNET_asprintf (&open_port_str, "%u", (unsigned int) open_port);
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,
358 GNUNET_assert (NULL != socket);
359 bind_status = GNUNET_NETWORK_socket_bind (socket,
363 GNUNET_NETWORK_socket_close (socket);
365 port_buckets[index] |= (1U << pos); /* Set the port bit */
366 if (GNUNET_OK == bind_status)
368 LOG (GNUNET_ERROR_TYPE_DEBUG,
369 "Found a free port %u\n", (unsigned int) open_port);
380 * Release reservation of a TCP or UDP port for a peer
381 * (used during GNUNET_TESTING_peer_destroy).
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
388 GNUNET_TESTING_release_port (struct GNUNET_TESTING_System *system,
392 uint32_t *port_buckets;
396 port_buckets = (GNUNET_YES == is_tcp) ?
397 system->reserved_tcp_ports : system->reserved_udp_ports;
400 LOG (GNUNET_ERROR_TYPE_DEBUG, "Releasing port %u\n", port);
401 if (0 == (port_buckets[bucket] & (1U << pos)))
403 GNUNET_break(0); /* Port was not reserved by us using reserve_port() */
406 port_buckets[bucket] &= ~(1U << pos);
411 * Reserve a SERVICEHOME path for a peer.
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
419 reserve_path (struct GNUNET_TESTING_System *system)
423 GNUNET_asprintf (&reserved_path,
424 "%s/%u", system->tmppath, system->path_counter++);
425 return reserved_path;
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.
437 * This is primarily a helper function used internally
438 * by 'GNUNET_TESTING_peer_configure'.
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)
446 struct GNUNET_CRYPTO_RsaPrivateKey *
447 GNUNET_TESTING_hostkey_get (const struct GNUNET_TESTING_System *system,
449 struct GNUNET_PeerIdentity *id)
451 struct GNUNET_CRYPTO_RsaPrivateKey *private_key;
452 struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded public_key;
454 if ((NULL == id) || (NULL == system->hostkeys_data))
456 if (key_number >= system->total_hostkeys)
458 LOG (GNUNET_ERROR_TYPE_ERROR,
459 _("Key number %u does not exist\n"), key_number);
462 private_key = GNUNET_CRYPTO_rsa_decode_key (system->hostkeys_data +
463 (key_number * HOSTKEYFILESIZE),
465 if (NULL == private_key)
467 LOG (GNUNET_ERROR_TYPE_ERROR,
468 _("Error while decoding key %u\n"), key_number);
471 GNUNET_CRYPTO_rsa_key_get_public (private_key, &public_key);
472 GNUNET_CRYPTO_hash (&public_key,
473 sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
480 * Structure for holding data to build new configurations from a configuration
486 * The system for which we are building configurations
488 struct GNUNET_TESTING_System *system;
491 * The configuration we are building
493 struct GNUNET_CONFIGURATION_Handle *cfg;
496 * The customized service home path for this peer
501 * build status - to signal error while building a configuration
508 * Function to iterate over options. Copies
509 * the options to the target configuration,
510 * updating PORT values as needed.
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
518 update_config (void *cls, const char *section, const char *option,
521 struct UpdateContext *uc = cls;
525 char *single_variable;
526 char *per_host_variable;
527 unsigned long long num_per_host;
530 if (GNUNET_OK != uc->status)
532 if (! ((0 == strcmp (option, "PORT"))
533 || (0 == strcmp (option, "UNIXPATH"))
534 || (0 == strcmp (option, "HOSTNAME"))))
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)))
542 GNUNET_CONFIGURATION_get_value_yesno (uc->cfg, "testing",
545 /* FIXME: What about UDP? */
546 new_port = GNUNET_TESTING_reserve_port (uc->system, GNUNET_YES);
549 uc->status = GNUNET_SYSERR;
552 GNUNET_snprintf (cval, sizeof (cval), "%u", new_port);
555 else if ((ival != 0) &&
557 GNUNET_CONFIGURATION_get_value_yesno (uc->cfg, "testing",
559 GNUNET_CONFIGURATION_get_value_number (uc->cfg, "testing",
563 /* GNUNET_snprintf (cval, sizeof (cval), "%u", */
564 /* ival + ctx->fdnum % num_per_host); */
566 GNUNET_break (0); /* FIXME */
569 if (0 == strcmp (option, "UNIXPATH"))
572 GNUNET_CONFIGURATION_get_value_yesno (uc->cfg, "testing",
575 GNUNET_snprintf (uval, sizeof (uval), "%s/%s.sock",
576 uc->service_home, section);
579 else if ((GNUNET_YES ==
580 GNUNET_CONFIGURATION_get_value_number (uc->cfg, "testing",
585 GNUNET_break(0); /* FIXME */
588 if ((0 == strcmp (option, "HOSTNAME")) && (NULL != uc->system->controller))
590 value = uc->system->controller;
592 GNUNET_free (single_variable);
593 GNUNET_free (per_host_variable);
594 GNUNET_CONFIGURATION_set_value_string (uc->cfg, section, option, value);
599 * Section iterator to set ACCEPT_FROM in all sections
601 * @param cls the UpdateContext
602 * @param section name of the section
605 update_config_sections (void *cls,
608 struct UpdateContext *uc = cls;
609 char *orig_allowed_hosts;
613 GNUNET_CONFIGURATION_get_value_string (uc->cfg, section, "ACCEPT_FROM",
614 &orig_allowed_hosts))
616 orig_allowed_hosts = GNUNET_strdup ("127.0.0.1;");
618 if (NULL == uc->system->controller)
619 allowed_hosts = GNUNET_strdup (orig_allowed_hosts);
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",
626 GNUNET_free (allowed_hosts);
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.
636 * This is primarily a helper function used internally
637 * by 'GNUNET_TESTING_peer_configure'.
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
645 GNUNET_TESTING_configuration_create (struct GNUNET_TESTING_System *system,
646 struct GNUNET_CONFIGURATION_Handle *cfg)
648 struct UpdateContext uc;
649 char *default_config;
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",
659 GNUNET_free (default_config);
660 GNUNET_CONFIGURATION_set_value_string (cfg, "PATHS", "SERVICEHOME",
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,
669 "USE_LOCALADDR", "YES");
670 GNUNET_free (uc.service_home);
676 * Configure a GNUnet peer. GNUnet must be installed on the local
677 * system and available in the PATH.
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
687 struct GNUNET_TESTING_Peer *
688 GNUNET_TESTING_peer_configure (struct GNUNET_TESTING_System *system,
689 struct GNUNET_CONFIGURATION_Handle *cfg,
691 struct GNUNET_PeerIdentity *id,
694 struct GNUNET_TESTING_Peer *peer;
695 struct GNUNET_DISK_FileHandle *fd;
697 char hostkey_filename[128];
698 char *config_filename;
700 struct GNUNET_CRYPTO_RsaPrivateKey *pk;
704 if (GNUNET_OK != GNUNET_TESTING_configuration_create (system, cfg))
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_);
715 if (key_number >= system->total_hostkeys)
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_);
729 (NULL == (pk = GNUNET_TESTING_hostkey_get (system, key_number, id))))
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_);
742 GNUNET_CRYPTO_rsa_key_free (pk);
743 GNUNET_assert (GNUNET_OK ==
744 GNUNET_CONFIGURATION_get_value_string (cfg, "PATHS",
747 GNUNET_snprintf (hostkey_filename, sizeof (hostkey_filename), "%s/.hostkey",
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);
759 if (HOSTKEYFILESIZE !=
760 GNUNET_DISK_file_write (fd, system->hostkeys_data
761 + (key_number * HOSTKEYFILESIZE),
764 GNUNET_asprintf (&emsg_,
765 _("Failed to write hostkey file for peer %u: %s\n"),
766 (unsigned int) key_number,
768 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s", *emsg_);
773 GNUNET_DISK_file_close (fd);
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))
782 GNUNET_asprintf (&emsg_,
783 _("Failed to write configuration file `%s' for peer %u: %s\n"),
785 (unsigned int) key_number,
787 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s", *emsg_);
792 GNUNET_free (config_filename);
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");
805 * @param peer peer to start
806 * @return GNUNET_OK on success, GNUNET_SYSERR on error (i.e. peer already running)
809 GNUNET_TESTING_peer_start (struct GNUNET_TESTING_Peer *peer)
811 if (NULL != peer->main_process)
814 return GNUNET_SYSERR;
816 GNUNET_assert (NULL != peer->cfgfile);
817 peer->main_process = GNUNET_OS_start_process (GNUNET_YES, NULL, NULL,
823 if (NULL == peer->main_process)
825 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
826 _("Failed to start `%s': %s\n"),
829 return GNUNET_SYSERR;
838 * @param peer peer to stop
839 * @return GNUNET_OK on success, GNUNET_SYSERR on error (i.e. peer not running)
842 GNUNET_TESTING_peer_stop (struct GNUNET_TESTING_Peer *peer)
844 if (NULL == peer->main_process)
847 return GNUNET_SYSERR;
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;
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).
862 * @param peer peer to destroy
865 GNUNET_TESTING_peer_destroy (struct GNUNET_TESTING_Peer *peer)
867 if (NULL != peer->main_process)
870 GNUNET_TESTING_peer_stop (peer);
872 GNUNET_free (peer->cfgfile);
873 GNUNET_free (peer->main_binary);
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'.
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
895 GNUNET_TESTING_peer_run (const char *testdir,
896 const char *cfgfilename,
897 GNUNET_TESTING_TestMain tm,
900 return GNUNET_TESTING_service_run (testdir, "arm",
901 cfgfilename, tm, tm_cls);
906 * Structure for holding service data
908 struct ServiceContext
911 * The configuration of the peer in which the service is run
913 const struct GNUNET_CONFIGURATION_Handle *cfg;
916 * Callback to signal service startup
918 GNUNET_TESTING_TestMain tm;
921 * Closure for the above callback
928 * Structure for holding service data
930 struct RestartableServiceContext
933 * The configuration of the peer in which the service is run
935 const struct GNUNET_CONFIGURATION_Handle *cfg;
938 * Callback to signal service startup
940 GNUNET_TESTING_RestartableTestMain tm;
943 * The peer in which the service is run.
945 const struct GNUNET_TESTING_Peer *peer;
948 * Closure for the above callback
955 * Callback to be called when SCHEDULER has been started
957 * @param cls the ServiceContext
958 * @param tc the TaskContext
961 service_run_main (void *cls,
962 const struct GNUNET_SCHEDULER_TaskContext *tc)
964 struct ServiceContext *sc = cls;
966 sc->tm (sc->tm_cls, sc->cfg);
971 * Callback to be called when SCHEDULER has been started
973 * @param cls the ServiceContext
974 * @param tc the TaskContext
977 service_run_restartable_main (void *cls,
978 const struct GNUNET_SCHEDULER_TaskContext *tc)
980 struct RestartableServiceContext *sc = cls;
982 sc->tm (sc->tm_cls, sc->cfg, sc->peer);
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'.
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.
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
1008 GNUNET_TESTING_service_run (const char *testdir,
1009 const char *service_name,
1010 const char *cfgfilename,
1011 GNUNET_TESTING_TestMain tm,
1014 struct ServiceContext sc;
1015 struct GNUNET_TESTING_System *system;
1016 struct GNUNET_TESTING_Peer *peer;
1017 struct GNUNET_CONFIGURATION_Handle *cfg;
1019 GNUNET_log_setup (testdir,
1022 system = GNUNET_TESTING_system_create (testdir, "127.0.0.1");
1025 cfg = GNUNET_CONFIGURATION_create ();
1026 if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg, cfgfilename))
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);
1034 peer = GNUNET_TESTING_peer_configure (system, cfg, 0, NULL, NULL);
1037 GNUNET_CONFIGURATION_destroy (cfg);
1038 hostkeys_unload (system);
1039 GNUNET_TESTING_system_destroy (system, GNUNET_YES);
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))
1046 GNUNET_TESTING_peer_destroy (peer);
1047 GNUNET_CONFIGURATION_destroy (cfg);
1048 GNUNET_TESTING_system_destroy (system, GNUNET_YES);
1054 GNUNET_SCHEDULER_run (&service_run_main, &sc); /* Scheduler loop */
1055 if (GNUNET_OK != GNUNET_TESTING_peer_stop (peer))
1057 GNUNET_TESTING_peer_destroy (peer);
1058 GNUNET_CONFIGURATION_destroy (cfg);
1059 GNUNET_TESTING_system_destroy (system, GNUNET_YES);
1062 GNUNET_TESTING_peer_destroy (peer);
1063 GNUNET_CONFIGURATION_destroy (cfg);
1064 GNUNET_TESTING_system_destroy (system, GNUNET_YES);
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.
1077 GNUNET_TESTING_service_run_restartable (const char *testdir,
1078 const char *service_name,
1079 const char *cfgfilename,
1080 GNUNET_TESTING_RestartableTestMain tm,
1083 struct RestartableServiceContext sc;
1084 struct GNUNET_TESTING_System *system;
1085 struct GNUNET_TESTING_Peer *peer;
1086 struct GNUNET_CONFIGURATION_Handle *cfg;
1088 GNUNET_log_setup (testdir,
1091 system = GNUNET_TESTING_system_create (testdir, "127.0.0.1");
1094 cfg = GNUNET_CONFIGURATION_create ();
1095 if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg, cfgfilename))
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);
1103 peer = GNUNET_TESTING_peer_configure (system, cfg, 0, NULL, NULL);
1106 GNUNET_CONFIGURATION_destroy (cfg);
1107 hostkeys_unload (system);
1108 GNUNET_TESTING_system_destroy (system, GNUNET_YES);
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))
1115 GNUNET_TESTING_peer_destroy (peer);
1116 GNUNET_CONFIGURATION_destroy (cfg);
1117 GNUNET_TESTING_system_destroy (system, GNUNET_YES);
1124 GNUNET_SCHEDULER_run (&service_run_restartable_main, &sc); /* Scheduler loop */
1125 if (GNUNET_OK != GNUNET_TESTING_peer_stop (peer))
1127 GNUNET_TESTING_peer_destroy (peer);
1128 GNUNET_CONFIGURATION_destroy (cfg);
1129 GNUNET_TESTING_system_destroy (system, GNUNET_YES);
1132 GNUNET_TESTING_peer_destroy (peer);
1133 GNUNET_CONFIGURATION_destroy (cfg);
1134 GNUNET_TESTING_system_destroy (system, GNUNET_YES);
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.
1145 * This function returns the respective substring, taking care
1146 * of issues such as binaries ending in '.exe' on W32.
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 '_'
1153 GNUNET_TESTING_get_testname_from_underscore (const char *argv0)
1155 size_t slen = strlen (argv0) + 1;
1160 memcpy (sbuf, argv0, slen);
1161 ret = strrchr (sbuf, '_');
1164 ret++; /* skip underscore */
1165 dot = strchr (ret, '.');
1168 return GNUNET_strdup (ret);
1172 /* end of testing.c */