/*
This file is part of GNUnet
- (C) 2008, 2009 Christian Grothoff (and other contributing authors)
+ (C) 2008, 2009, 2012 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 2, or (at your
+ by the Free Software Foundation; either version 3, or (at your
option) any later version.
GNUnet is distributed in the hope that it will be useful, but
/**
* @file testing/testing.c
* @brief convenience API for writing testcases for GNUnet
- * Many testcases need to start and stop gnunetd,
+ * Many testcases need to start and stop a peer/service
* and this library is supposed to make that easier
* for TESTCASES. Normal programs should always
* use functions from gnunet_{util,arm}_lib.h. This API is
- * ONLY for writing testcases!
+ * ONLY for writing testcases (or internal use of the testbed).
* @author Christian Grothoff
*
- * TODO:
- * - modify configuration to allow 2087-connections from
- * controlling host (otherwise shutdown won't work)
- *
*/
#include "platform.h"
-#include "gnunet_arm_service.h"
-#include "gnunet_core_service.h"
-#include "gnunet_constants.h"
-#include "gnunet_testing_lib.h"
-#include "gnunet_transport_service.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_lib-new.h"
-#define DEBUG_TESTING GNUNET_NO
+#define LOG(kind,...) \
+ GNUNET_log_from (kind, "testing-api", __VA_ARGS__)
/**
- * How long do we wait after starting gnunet-service-arm
- * for the core service to be alive?
+ * Lowest port used for GNUnet testing. Should be high enough to not
+ * conflict with other applications running on the hosts but be low
+ * enough to not conflict with client-ports (typically starting around
+ * 32k).
*/
-#define ARM_START_WAIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
+#define LOW_PORT 12000
/**
- * How many times are we willing to try to wait for "scp" or
- * "gnunet-service-arm" to complete (waitpid) before giving up?
+ * Highest port used for GNUnet testing. Should be low enough to not
+ * conflict with the port range for "local" ports (client apps; see
+ * /proc/sys/net/ipv4/ip_local_port_range on Linux for example).
*/
-#define MAX_EXEC_WAIT_RUNS 50
-
-/**
- * Phases of starting GNUnet on a system.
- */
-enum StartPhase
- {
- /**
- * Copy the configuration file to the target system.
- */
- SP_COPYING,
-
- /**
- * Configuration file has been copied, start ARM on target system.
- */
- SP_COPIED,
-
- /**
- * ARM has been started, check that it has properly daemonized and
- * then try to connect to the CORE service (which should be
- * auto-started by ARM).
- */
- SP_START_ARMING,
-
- /**
- * We're waiting for CORE to start.
- */
- SP_START_CORE,
-
- /**
- * Core has notified us that we've established a connection to the service.
- * The main FSM halts here and waits to be moved to UPDATE or CLEANUP.
- */
- SP_START_DONE,
-
- /**
- * We've been asked to terminate the instance and are now waiting for
- * the remote command to delete the configuration file to complete.
- */
- SP_CLEANUP,
-
- /**
- * We've received a configuration update and are currently waiting for
- * the copy process for the update to complete. Once it is, we will
- * return to "SP_START_DONE" (and rely on ARM to restart all affected
- * services).
- */
- SP_CONFIG_UPDATE
- };
+#define HIGH_PORT 56000
/**
- * Handle for a GNUnet daemon (technically a set of
- * daemons; the handle is really for the master ARM
- * daemon) started by the testing library.
+ * Handle for a system on which GNUnet peers are executed;
+ * a system is used for reserving unique paths and ports.
*/
-struct GNUNET_TESTING_Daemon
+struct GNUNET_TESTING_System
{
/**
- * Our scheduler.
- */
- struct GNUNET_SCHEDULER_Handle *sched;
+ * Prefix (i.e. "/tmp/gnunet-testing/") we prepend to each
+ * SERVICEHOME. */
+ char *tmppath;
/**
- * Our configuration.
+ * The hostname of the controller
*/
- struct GNUNET_CONFIGURATION_Handle *cfg;
+ char *controller;
/**
- * Host to run GNUnet on.
+ * our hostname
*/
char *hostname;
/**
- * Username we are using.
+ * Hostkeys data, contains "GNUNET_TESTING_HOSTKEYFILESIZE * total_hostkeys" bytes.
*/
- char *username;
+ char *hostkeys_data;
/**
- * Name of the configuration file
+ * memory map for 'hostkeys_data'.
*/
- char *cfgfile;
+ struct GNUNET_DISK_MapHandle *map;
/**
- * Function to call when the peer is running.
+ * File descriptor for the map.
*/
- GNUNET_TESTING_NotifyDaemonRunning cb;
+ struct GNUNET_DISK_FileHandle *map_fd;
/**
- * Closure for cb.
+ * Bitmap where each TCP port that has already been reserved for
+ * some GNUnet peer is recorded. Note that we additionally need to
+ * test if a port is already in use by non-GNUnet components before
+ * assigning it to a peer/service. If we detect that a port is
+ * already in use, we also mark it in this bitmap. So all the bits
+ * that are zero merely indicate ports that MIGHT be available for
+ * peers.
*/
- void *cb_cls;
+ uint32_t reserved_tcp_ports[65536 / 32];
/**
- * Arguments from "daemon_stop" call.
+ * Bitmap where each UDP port that has already been reserved for
+ * some GNUnet peer is recorded. Note that we additionally need to
+ * test if a port is already in use by non-GNUnet components before
+ * assigning it to a peer/service. If we detect that a port is
+ * already in use, we also mark it in this bitmap. So all the bits
+ * that are zero merely indicate ports that MIGHT be available for
+ * peers.
*/
- GNUNET_TESTING_NotifyCompletion dead_cb;
+ uint32_t reserved_udp_ports[65536 / 32];
/**
- * Closure for 'dead_cb'.
+ * Counter we use to make service home paths unique on this system;
+ * the full path consists of the tmppath and this number. Each
+ * UNIXPATH for a peer is also modified to include the respective
+ * path counter to ensure uniqueness. This field is incremented
+ * by one for each configured peer. Even if peers are destroyed,
+ * we never re-use path counters.
*/
- void *dead_cb_cls;
+ uint32_t path_counter;
/**
- * Arguments from "daemon_stop" call.
+ * The number of hostkeys
*/
- GNUNET_TESTING_NotifyCompletion update_cb;
+ uint32_t total_hostkeys;
/**
- * Closure for 'update_cb'.
+ * Lowest port we are allowed to use.
*/
- void *update_cb_cls;
+ uint16_t lowport;
/**
- * Identity of this peer (once started).
+ * Highest port we are allowed to use.
*/
- struct GNUNET_PeerIdentity id;
+ uint16_t highport;
+};
- /**
- * Flag to indicate that we've already been asked
- * to terminate (but could not because some action
- * was still pending).
- */
- int dead;
+/**
+ * Handle for a GNUnet peer controlled by testing.
+ */
+struct GNUNET_TESTING_Peer
+{
/**
- * PID of the process that we started last.
+ * The TESTING system associated with this peer
*/
- pid_t pid;
+ struct GNUNET_TESTING_System *system;
/**
- * How many iterations have we been waiting for
- * the started process to complete?
+ * Path to the configuration file for this peer.
*/
- unsigned int wait_runs;
+ char *cfgfile;
/**
- * In which phase are we during the start of
- * this process?
- */
- enum StartPhase phase;
-
+ * Binary to be executed during 'GNUNET_TESTING_peer_start'.
+ * Typically 'gnunet-service-arm' (but can be set to a
+ * specific service by 'GNUNET_TESTING_service_run' if
+ * necessary).
+ */
+ char *main_binary;
+
/**
- * ID of the current task.
+ * Handle to the running binary of the service, NULL if the
+ * peer/service is currently not running.
*/
- GNUNET_SCHEDULER_TaskIdentifier task;
+ struct GNUNET_OS_Process *main_process;
/**
- * Handle to the server.
- */
- struct GNUNET_CORE_Handle * server;
+ * The keynumber of this peer's hostkey
+ */
+ uint32_t key_number;
};
/**
- * Function called after GNUNET_CORE_connect has succeeded
- * (or failed for good). Note that the private key of the
- * peer is intentionally not exposed here; if you need it,
- * your process should try to read the private key file
- * directly (which should work if you are authorized...).
+ * Testing includes a number of pre-created hostkeys for faster peer
+ * startup. This function loads such keys into memory from a file.
*
- * @param cls closure
- * @param server handle to the server, NULL if we failed
- * @param my_identity ID of this peer, NULL if we failed
- * @param publicKey public key of this peer, NULL if we failed
+ * @param system the testing system handle
+ * @return GNUNET_OK on success; GNUNET_SYSERR on error
*/
-static void
-testing_init (void *cls,
- struct GNUNET_CORE_Handle * server,
- const struct GNUNET_PeerIdentity *
- my_identity,
- const struct
- GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *
- publicKey)
+static int
+hostkeys_load (struct GNUNET_TESTING_System *system)
{
- struct GNUNET_TESTING_Daemon *d = cls;
- GNUNET_TESTING_NotifyDaemonRunning cb;
-
- GNUNET_assert (d->phase == SP_START_CORE);
- d->phase = SP_START_DONE;
- cb = d->cb;
- d->cb = NULL;
- if (server == NULL)
- {
- d->server = NULL;
- if (GNUNET_YES == d->dead)
- GNUNET_TESTING_daemon_stop (d, d->dead_cb, d->dead_cb_cls);
- else if (NULL != cb)
- cb (d->cb_cls, NULL, d->cfg, d,
- _("Failed to connect to core service\n"));
- return;
- }
-#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Successfully started peer `%4s'.\n",
- GNUNET_i2s(my_identity));
-#endif
- d->id = *my_identity;
- d->server = server;
- if (GNUNET_YES == d->dead)
- GNUNET_TESTING_daemon_stop (d, d->dead_cb, d->dead_cb_cls);
- else if (NULL != cb)
- cb (d->cb_cls, my_identity, d->cfg, d, NULL);
+ uint64_t fs;
+ char *data_dir;
+ char *filename;
+
+ GNUNET_assert (NULL == system->hostkeys_data);
+ data_dir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_DATADIR);
+ GNUNET_asprintf (&filename, "%s/testing_hostkeys.dat", data_dir);
+ GNUNET_free (data_dir);
+
+ if (GNUNET_YES != GNUNET_DISK_file_test (filename))
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Hostkeys file not found: %s\n"), filename);
+ GNUNET_free (filename);
+ return GNUNET_SYSERR;
+ }
+ /* Check hostkey file size, read entire thing into memory */
+ if (GNUNET_OK !=
+ GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
+ fs = 0;
+ if (0 == fs)
+ {
+ GNUNET_free (filename);
+ return GNUNET_SYSERR; /* File is empty */
+ }
+ if (0 != (fs % GNUNET_TESTING_HOSTKEYFILESIZE))
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Incorrect hostkey file format: %s\n"), filename);
+ GNUNET_free (filename);
+ return GNUNET_SYSERR;
+ }
+ system->map_fd = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ,
+ GNUNET_DISK_PERM_NONE);
+ if (NULL == system->map_fd)
+ {
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", filename);
+ GNUNET_free (filename);
+ return GNUNET_SYSERR;
+ }
+ system->total_hostkeys = fs / GNUNET_TESTING_HOSTKEYFILESIZE;
+ system->hostkeys_data = GNUNET_DISK_file_map (system->map_fd,
+ &system->map,
+ GNUNET_DISK_MAP_TYPE_READ,
+ fs);
+ GNUNET_free (filename);
+ return GNUNET_OK;
}
/**
- * Finite-state machine for starting GNUnet.
+ * Function to remove the loaded hostkeys
*
- * @param cls our "struct GNUNET_TESTING_Daemon"
- * @param tc unused
+ * @param system the testing system handle
*/
static void
-start_fsm (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+hostkeys_unload (struct GNUNET_TESTING_System *system)
{
- static struct GNUNET_CORE_MessageHandler no_handlers[] =
- { { NULL, 0, 0 } };
- struct GNUNET_TESTING_Daemon * d = cls;
- GNUNET_TESTING_NotifyDaemonRunning cb;
- enum GNUNET_OS_ProcessStatusType type;
- unsigned long code;
- char *dst;
-
-#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Peer FSM is in phase %u.\n",
- d->phase);
-#endif
- d->task = GNUNET_SCHEDULER_NO_TASK;
- switch (d->phase)
- {
- case SP_COPYING:
- /* confirm copying complete */
- if (GNUNET_OK !=
- GNUNET_OS_process_status (d->pid,
- &type,
- &code))
- {
- d->wait_runs++;
- if (d->wait_runs > MAX_EXEC_WAIT_RUNS)
- {
- cb = d->cb;
- d->cb = NULL;
- if (NULL != cb)
- cb (d->cb_cls,
- NULL,
- d->cfg,
- d,
- _("`scp' does not seem to terminate.\n"));
- return;
- }
- /* wait some more */
- d->task
- = GNUNET_SCHEDULER_add_delayed (d->sched,
- GNUNET_CONSTANTS_EXEC_WAIT,
- &start_fsm,
- d);
- return;
- }
- if ( (type != GNUNET_OS_PROCESS_EXITED) ||
- (code != 0) )
- {
- cb = d->cb;
- d->cb = NULL;
- if (NULL != cb)
- cb (d->cb_cls,
- NULL,
- d->cfg,
- d,
- _("`scp' did not complete cleanly.\n"));
- return;
- }
-#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Successfully copied configuration file.\n");
-#endif
- d->phase = SP_COPIED;
- /* fall-through */
- case SP_COPIED:
- /* start GNUnet on remote host */
- if (NULL == d->hostname)
- {
- d->pid = GNUNET_OS_start_process ("gnunet-service-arm",
- "gnunet-service-arm",
- "-c",
- d->cfgfile,
-#if DEBUG_TESTING
- "-L", "DEBUG",
-#endif
- "-d",
- NULL);
- }
- else
- {
- if (d->username != NULL)
- GNUNET_asprintf (&dst,
- "%s@%s",
- d->username,
- d->hostname);
- else
- dst = GNUNET_strdup (d->hostname);
- d->pid = GNUNET_OS_start_process ("ssh",
- "ssh",
- dst,
- "gnunet-service-arm",
- "-c",
- d->cfgfile,
- "-d",
- NULL);
- GNUNET_free (dst);
- }
- if (-1 == d->pid)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Could not start `%s' process to start GNUnet.\n"),
- (NULL == d->hostname) ? "gnunet-service-arm" : "ssh");
- cb = d->cb;
- d->cb = NULL;
- if (NULL != cb)
- cb (d->cb_cls,
- NULL,
- d->cfg,
- d,
- (NULL == d->hostname)
- ? _("Failed to start `gnunet-service-arm' process.\n")
- : _("Failed to start `ssh' process.\n"));
- }
-#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Started `%s', waiting for `%s' to be up.\n",
- "gnunet-service-arm",
- "gnunet-service-core");
-#endif
- d->phase = SP_START_ARMING;
- d->wait_runs = 0;
- d->task
- = GNUNET_SCHEDULER_add_delayed (d->sched,
- GNUNET_CONSTANTS_EXEC_WAIT,
- &start_fsm,
- d);
- break;
- case SP_START_ARMING:
- if (GNUNET_OK !=
- GNUNET_OS_process_status (d->pid,
- &type,
- &code))
- {
- d->wait_runs++;
- if (d->wait_runs > MAX_EXEC_WAIT_RUNS)
- {
- cb = d->cb;
- d->cb = NULL;
- if (NULL != cb)
- cb (d->cb_cls,
- NULL,
- d->cfg,
- d,
- (NULL == d->hostname)
- ? _("`gnunet-service-arm' does not seem to terminate.\n")
- : _("`ssh' does not seem to terminate.\n"));
- return;
- }
- /* wait some more */
- d->task
- = GNUNET_SCHEDULER_add_delayed (d->sched,
- GNUNET_CONSTANTS_EXEC_WAIT,
- &start_fsm,
- d);
- return;
- }
-#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Successfully started `%s'.\n",
- "gnunet-service-arm");
-#endif
- d->phase = SP_START_CORE;
- d->server = GNUNET_CORE_connect (d->sched,
- d->cfg,
- ARM_START_WAIT,
- d,
- &testing_init,
- NULL, NULL, NULL,
- NULL, GNUNET_NO,
- NULL, GNUNET_NO,
- no_handlers);
- break;
- case SP_START_CORE:
- GNUNET_break (0);
- break;
- case SP_START_DONE:
- GNUNET_break (0);
- break;
- case SP_CLEANUP:
- /* confirm copying complete */
- if (GNUNET_OK !=
- GNUNET_OS_process_status (d->pid,
- &type,
- &code))
- {
- d->wait_runs++;
- if (d->wait_runs > MAX_EXEC_WAIT_RUNS)
- {
- d->dead_cb (d->dead_cb_cls,
- _("`ssh' does not seem to terminate.\n"));
- GNUNET_free (d->cfgfile);
- GNUNET_free_non_null (d->hostname);
- GNUNET_free_non_null (d->username);
- GNUNET_free (d);
- return;
- }
- /* wait some more */
- d->task
- = GNUNET_SCHEDULER_add_delayed (d->sched,
- GNUNET_CONSTANTS_EXEC_WAIT,
- &start_fsm,
- d);
- return;
- }
- if ( (type != GNUNET_OS_PROCESS_EXITED) ||
- (code != 0) )
- {
- if (NULL != d->dead_cb)
- d->dead_cb (d->dead_cb_cls,
- _("`ssh' did not complete cleanly.\n"));
- GNUNET_free (d->cfgfile);
- GNUNET_free_non_null (d->hostname);
- GNUNET_free_non_null (d->username);
- GNUNET_free (d);
- return;
- }
-#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Peer shutdown complete.\n");
-#endif
- GNUNET_free (d->cfgfile);
- GNUNET_free_non_null (d->hostname);
- GNUNET_free_non_null (d->username);
- if (NULL != d->dead_cb)
- d->dead_cb (d->dead_cb_cls, NULL);
- GNUNET_free (d);
- break;
- case SP_CONFIG_UPDATE:
- /* confirm copying complete */
- if (GNUNET_OK !=
- GNUNET_OS_process_status (d->pid,
- &type,
- &code))
- {
- d->wait_runs++;
- if (d->wait_runs > MAX_EXEC_WAIT_RUNS)
- {
- cb = d->cb;
- d->cb = NULL;
- if (NULL != cb)
- cb (d->cb_cls,
- NULL,
- d->cfg,
- d,
- _("`scp' does not seem to terminate.\n"));
- return;
- }
- /* wait some more */
- d->task
- = GNUNET_SCHEDULER_add_delayed (d->sched,
- GNUNET_CONSTANTS_EXEC_WAIT,
- &start_fsm,
- d);
- return;
- }
- if ( (type != GNUNET_OS_PROCESS_EXITED) ||
- (code != 0) )
- {
- if (NULL != d->update_cb)
- d->update_cb (d->update_cb_cls,
- _("`scp' did not complete cleanly.\n"));
- return;
- }
-#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Successfully copied configuration file.\n");
-#endif
- if (NULL != d->update_cb)
- d->update_cb (d->update_cb_cls, NULL);
- d->phase = SP_START_DONE;
- break;
- }
+ GNUNET_break (NULL != system->hostkeys_data);
+ system->hostkeys_data = NULL;
+ GNUNET_DISK_file_unmap (system->map);
+ system->map = NULL;
+ GNUNET_DISK_file_close (system->map_fd);
+ system->map_fd = NULL;
+ system->hostkeys_data = NULL;
+ system->total_hostkeys = 0;
}
/**
- * Starts a GNUnet daemon. GNUnet must be installed on the target
- * system and available in the PATH. The machine must furthermore be
- * reachable via "ssh" (unless the hostname is "NULL") without the
- * need to enter a password.
+ * Create a system handle. There must only be one system
+ * handle per operating system.
*
- * @param sched scheduler to use
- * @param cfg configuration to use
- * @param hostname name of the machine where to run GNUnet
- * (use NULL for localhost).
- * @param cb function to call with the result
- * @param cb_cls closure for cb
- * @return handle to the daemon (actual start will be completed asynchronously)
+ * @param testdir only the directory name without any path. This is used for
+ * all service homes; the directory will be created in a temporary
+ * location depending on the underlying OS
+ * @param controller hostname of the controlling host,
+ * service configurations are modified to allow
+ * control connections from this host; can be NULL
+ * @param hostname the hostname of the system we are using for testing; NULL for
+ * localhost
+ * @param lowport lowest port number this system is allowed to allocate (inclusive)
+ * @param highport highest port number this system is allowed to allocate (exclusive)
+ * @return handle to this system, NULL on error
*/
-struct GNUNET_TESTING_Daemon *
-GNUNET_TESTING_daemon_start (struct GNUNET_SCHEDULER_Handle *sched,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
- const char *hostname,
- GNUNET_TESTING_NotifyDaemonRunning cb,
- void *cb_cls)
+struct GNUNET_TESTING_System *
+GNUNET_TESTING_system_create_with_portrange (const char *testdir,
+ const char *controller,
+ const char *hostname,
+ uint16_t lowport,
+ uint16_t highport)
{
- struct GNUNET_TESTING_Daemon * ret;
- char *arg;
- char *username;
-
- ret = GNUNET_malloc (sizeof(struct GNUNET_TESTING_Daemon));
- ret->sched = sched;
- ret->hostname = (hostname == NULL) ? NULL : GNUNET_strdup (hostname);
- ret->cfgfile = GNUNET_DISK_mktemp ("gnunet-testing-config");
-#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Setting up peer with configuration file `%s'.\n",
- ret->cfgfile);
-#endif
- if (NULL == ret->cfgfile)
- {
- GNUNET_free_non_null (ret->hostname);
- GNUNET_free (ret);
- return NULL;
- }
- ret->cb = cb;
- ret->cb_cls = cb_cls;
- ret->cfg = GNUNET_CONFIGURATION_dup (cfg);
- GNUNET_CONFIGURATION_set_value_string (ret->cfg,
- "PATHS",
- "DEFAULTCONFIG",
- ret->cfgfile);
- /* 1) write configuration to temporary file */
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_write (ret->cfg,
- ret->cfgfile))
- {
- if (0 != UNLINK (ret->cfgfile))
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
- "unlink",
- ret->cfgfile);
- GNUNET_CONFIGURATION_destroy (ret->cfg);
- GNUNET_free_non_null (ret->hostname);
- GNUNET_free (ret->cfgfile);
- GNUNET_free (ret);
- return NULL;
- }
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_string (cfg,
- "TESTING",
- "USERNAME",
- &username))
- {
- if (NULL != getenv ("USER"))
- username = GNUNET_strdup (getenv("USER"));
- else
- username = NULL;
- }
- ret->username = username;
+ struct GNUNET_TESTING_System *system;
+
+ GNUNET_assert (NULL != testdir);
+ system = GNUNET_malloc (sizeof (struct GNUNET_TESTING_System));
+ system->tmppath = GNUNET_DISK_mkdtemp (testdir);
+ system->lowport = lowport;
+ system->highport = highport;
+ if (NULL == system->tmppath)
+ {
+ GNUNET_free (system);
+ return NULL;
+ }
+ if (NULL != controller)
+ system->controller = GNUNET_strdup (controller);
+ if (NULL != hostname)
+ system->hostname = GNUNET_strdup (hostname);
+ if (GNUNET_OK != hostkeys_load (system))
+ {
+ GNUNET_TESTING_system_destroy (system, GNUNET_YES);
+ return NULL;
+ }
+ return system;
+}
+
+
+/**
+ * Create a system handle. There must only be one system handle per operating
+ * system. Uses a default range for allowed ports. Ports are still tested for
+ * availability.
+ *
+ * @param testdir only the directory name without any path. This is used for all
+ * service homes; the directory will be created in a temporary location
+ * depending on the underlying OS
+ * @param controller hostname of the controlling host, service configurations
+ * are modified to allow control connections from this host; can be NULL
+ * @param hostname the hostname of the system we are using for testing; NULL for
+ * localhost
+ * @return handle to this system, NULL on error
+ */
+struct GNUNET_TESTING_System *
+GNUNET_TESTING_system_create (const char *testdir,
+ const char *controller,
+ const char *hostname)
+{
+ return GNUNET_TESTING_system_create_with_portrange (testdir,
+ controller,
+ hostname,
+ LOW_PORT,
+ HIGH_PORT);
+}
+
+
+/**
+ * Free system resources.
+ *
+ * @param system system to be freed
+ * @param remove_paths should the 'testdir' and all subdirectories
+ * be removed (clean up on shutdown)?
+ */
+void
+GNUNET_TESTING_system_destroy (struct GNUNET_TESTING_System *system,
+ int remove_paths)
+{
+ if (NULL != system->hostkeys_data)
+ hostkeys_unload (system);
+ if (GNUNET_YES == remove_paths)
+ GNUNET_DISK_directory_remove (system->tmppath);
+ GNUNET_free (system->tmppath);
+ GNUNET_free_non_null (system->controller);
+ GNUNET_free_non_null (system->hostname);
+ GNUNET_free (system);
+}
- /* 2) copy file to remote host */
- if (NULL != hostname)
+
+/**
+ * Reserve a TCP or UDP port for a peer.
+ *
+ * @param system system to use for reservation tracking
+ * @param is_tcp GNUNET_YES for TCP ports, GNUNET_NO for UDP
+ * @return 0 if no free port was available
+ */
+uint16_t
+GNUNET_TESTING_reserve_port (struct GNUNET_TESTING_System *system,
+ int is_tcp)
+{
+ struct GNUNET_NETWORK_Handle *socket;
+ struct addrinfo hint;
+ struct addrinfo *ret;
+ struct addrinfo *ai;
+ uint32_t *port_buckets;
+ char *open_port_str;
+ int bind_status;
+ uint32_t xor_image;
+ uint16_t index;
+ uint16_t open_port;
+ uint16_t pos;
+
+ /*
+ FIXME: Instead of using getaddrinfo we should try to determine the port
+ status by the following heurestics.
+
+ On systems which support both IPv4 and IPv6, only ports open on both
+ address families are considered open.
+ On system with either IPv4 or IPv6. A port is considered open if it's
+ open in the respective address family
+ */
+ hint.ai_family = AF_UNSPEC; /* IPv4 and IPv6 */
+ hint.ai_socktype = (GNUNET_YES == is_tcp)? SOCK_STREAM : SOCK_DGRAM;
+ hint.ai_protocol = 0;
+ hint.ai_addrlen = 0;
+ hint.ai_addr = NULL;
+ hint.ai_canonname = NULL;
+ hint.ai_next = NULL;
+ hint.ai_flags = AI_PASSIVE | AI_NUMERICSERV; /* Wild card address */
+ port_buckets = (GNUNET_YES == is_tcp) ?
+ system->reserved_tcp_ports : system->reserved_udp_ports;
+ for (index = (system->lowport / 32) + 1; index < (system->highport / 32); index++)
+ {
+ xor_image = (UINT32_MAX ^ port_buckets[index]);
+ if (0 == xor_image) /* Ports in the bucket are full */
+ continue;
+ pos = system->lowport % 32;
+ while (pos < 32)
{
-#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Copying configuration file to host `%s'.\n",
- hostname);
-#endif
- ret->phase = SP_COPYING;
- if (NULL != username)
- GNUNET_asprintf (&arg,
- "%s@%s:%s",
- username,
- hostname,
- ret->cfgfile);
- else
- GNUNET_asprintf (&arg,
- "%s:%s",
- hostname,
- ret->cfgfile);
- ret->pid = GNUNET_OS_start_process ("scp",
- "scp",
- ret->cfgfile,
- arg,
- NULL);
- GNUNET_free (arg);
- if (-1 == ret->pid)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Could not start `%s' process to copy configuration file.\n"),
- "scp");
- if (0 != UNLINK (ret->cfgfile))
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
- "unlink",
- ret->cfgfile);
- GNUNET_CONFIGURATION_destroy (ret->cfg);
- GNUNET_free_non_null (ret->hostname);
- GNUNET_free_non_null (ret->username);
- GNUNET_free (ret->cfgfile);
- GNUNET_free (ret);
- return NULL;
- }
- ret->task
- = GNUNET_SCHEDULER_add_delayed (sched,
- GNUNET_CONSTANTS_EXEC_WAIT,
- &start_fsm,
- ret);
- return ret;
+ if (0 == ((xor_image >> pos) & 1U))
+ {
+ pos++;
+ continue;
+ }
+ open_port = (index * 32) + pos;
+ if (open_port >= system->highport)
+ return 0;
+ GNUNET_asprintf (&open_port_str, "%u", (unsigned int) open_port);
+ ret = NULL;
+ GNUNET_assert (0 == getaddrinfo (NULL, open_port_str, &hint, &ret));
+ GNUNET_free (open_port_str);
+ bind_status = GNUNET_NO;
+ for (ai = ret; NULL != ai; ai = ai->ai_next)
+ {
+ socket = GNUNET_NETWORK_socket_create (ai->ai_family,
+ (GNUNET_YES == is_tcp) ?
+ SOCK_STREAM : SOCK_DGRAM,
+ 0);
+ if (NULL == socket)
+ continue;
+ bind_status = GNUNET_NETWORK_socket_bind (socket,
+ ai->ai_addr,
+ ai->ai_addrlen);
+ GNUNET_NETWORK_socket_close (socket);
+ if (GNUNET_OK != bind_status)
+ break;
+ }
+ port_buckets[index] |= (1U << pos); /* Set the port bit */
+ freeaddrinfo (ret);
+ if (GNUNET_OK == bind_status)
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Found a free port %u\n", (unsigned int) open_port);
+ return open_port;
+ }
+ pos++;
}
-#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "No need to copy configuration file since we are running locally.\n");
-#endif
- ret->phase = SP_COPIED;
- GNUNET_SCHEDULER_add_continuation (sched,
- &start_fsm,
- ret,
- GNUNET_SCHEDULER_REASON_PREREQ_DONE);
- return ret;
+ }
+ return 0;
+}
+
+
+/**
+ * Release reservation of a TCP or UDP port for a peer
+ * (used during GNUNET_TESTING_peer_destroy).
+ *
+ * @param system system to use for reservation tracking
+ * @param is_tcp GNUNET_YES for TCP ports, GNUNET_NO for UDP
+ * @param port reserved port to release
+ */
+void
+GNUNET_TESTING_release_port (struct GNUNET_TESTING_System *system,
+ int is_tcp,
+ uint16_t port)
+{
+ uint32_t *port_buckets;
+ uint16_t bucket;
+ uint16_t pos;
+
+ port_buckets = (GNUNET_YES == is_tcp) ?
+ system->reserved_tcp_ports : system->reserved_udp_ports;
+ bucket = port / 32;
+ pos = port % 32;
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Releasing port %u\n", port);
+ if (0 == (port_buckets[bucket] & (1U << pos)))
+ {
+ GNUNET_break(0); /* Port was not reserved by us using reserve_port() */
+ return;
+ }
+ port_buckets[bucket] &= ~(1U << pos);
}
/**
- * Stops a GNUnet daemon.
+ * Reserve a SERVICEHOME path for a peer.
*
- * @param d the daemon that should be stopped
- * @param cb function called once the daemon was stopped
- * @param cb_cls closure for cb
+ * @param system system to use for reservation tracking
+ * @return NULL on error, otherwise fresh unique path to use
+ * as the servicehome for the peer; must be freed by the caller
*/
-void GNUNET_TESTING_daemon_stop (struct GNUNET_TESTING_Daemon *d,
- GNUNET_TESTING_NotifyCompletion cb,
- void * cb_cls)
+// static
+char *
+reserve_path (struct GNUNET_TESTING_System *system)
{
- struct GNUNET_CLIENT_Connection *cc;
- char *dst;
+ char *reserved_path;
- if (NULL != d->cb)
+ GNUNET_asprintf (&reserved_path,
+ "%s/%u", system->tmppath, system->path_counter++);
+ return reserved_path;
+}
+
+
+/**
+ * Testing includes a number of pre-created hostkeys for
+ * faster peer startup. This function can be used to
+ * access the n-th key of those pre-created hostkeys; note
+ * that these keys are ONLY useful for testing and not
+ * secure as the private keys are part of the public
+ * GNUnet source code.
+ *
+ * This is primarily a helper function used internally
+ * by 'GNUNET_TESTING_peer_configure'.
+ *
+ * @param system the testing system handle
+ * @param key_number desired pre-created hostkey to obtain
+ * @param id set to the peer's identity (hash of the public
+ * key; if NULL, GNUNET_SYSERR is returned immediately
+ * @return NULL on error (not enough keys)
+ */
+struct GNUNET_CRYPTO_RsaPrivateKey *
+GNUNET_TESTING_hostkey_get (const struct GNUNET_TESTING_System *system,
+ uint32_t key_number,
+ struct GNUNET_PeerIdentity *id)
+{
+ struct GNUNET_CRYPTO_RsaPrivateKey *private_key;
+ struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded public_key;
+
+ if ((NULL == id) || (NULL == system->hostkeys_data))
+ return NULL;
+ if (key_number >= system->total_hostkeys)
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Key number %u does not exist\n"), key_number);
+ return NULL;
+ }
+ private_key = GNUNET_CRYPTO_rsa_decode_key (system->hostkeys_data +
+ (key_number *
+ GNUNET_TESTING_HOSTKEYFILESIZE),
+ GNUNET_TESTING_HOSTKEYFILESIZE);
+ if (NULL == private_key)
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Error while decoding key %u\n"), key_number);
+ return NULL;
+ }
+ GNUNET_CRYPTO_rsa_key_get_public (private_key, &public_key);
+ GNUNET_CRYPTO_hash (&public_key,
+ sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+ &(id->hashPubKey));
+ return private_key;
+}
+
+
+/**
+ * Structure for holding data to build new configurations from a configuration
+ * template
+ */
+struct UpdateContext
+{
+ /**
+ * The system for which we are building configurations
+ */
+ struct GNUNET_TESTING_System *system;
+
+ /**
+ * The configuration we are building
+ */
+ struct GNUNET_CONFIGURATION_Handle *cfg;
+
+ /**
+ * The customized service home path for this peer
+ */
+ char *service_home;
+
+ /**
+ * build status - to signal error while building a configuration
+ */
+ int status;
+};
+
+
+/**
+ * Function to iterate over options. Copies
+ * the options to the target configuration,
+ * updating PORT values as needed.
+ *
+ * @param cls the UpdateContext
+ * @param section name of the section
+ * @param option name of the option
+ * @param value value of the option
+ */
+static void
+update_config (void *cls, const char *section, const char *option,
+ const char *value)
+{
+ struct UpdateContext *uc = cls;
+ unsigned int ival;
+ char cval[12];
+ char uval[128];
+ char *single_variable;
+ char *per_host_variable;
+ unsigned long long num_per_host;
+ uint16_t new_port;
+
+ if (GNUNET_OK != uc->status)
+ return;
+ if (! ((0 == strcmp (option, "PORT"))
+ || (0 == strcmp (option, "UNIXPATH"))
+ || (0 == strcmp (option, "HOSTNAME"))))
+ return;
+ GNUNET_asprintf (&single_variable, "single_%s_per_host", section);
+ GNUNET_asprintf (&per_host_variable, "num_%s_per_host", section);
+ if ((0 == strcmp (option, "PORT")) && (1 == SSCANF (value, "%u", &ival)))
+ {
+ if ((ival != 0) &&
+ (GNUNET_YES !=
+ GNUNET_CONFIGURATION_get_value_yesno (uc->cfg, "testing",
+ single_variable)))
{
- d->dead = GNUNET_YES;
- d->dead_cb = cb;
- d->dead_cb_cls = cb_cls;
- return;
+ /* FIXME: What about UDP? */
+ new_port = GNUNET_TESTING_reserve_port (uc->system, GNUNET_YES);
+ if (0 == new_port)
+ {
+ uc->status = GNUNET_SYSERR;
+ return;
+ }
+ GNUNET_snprintf (cval, sizeof (cval), "%u", new_port);
+ value = cval;
}
- if (d->phase == SP_CONFIG_UPDATE)
+ else if ((ival != 0) &&
+ (GNUNET_YES ==
+ GNUNET_CONFIGURATION_get_value_yesno (uc->cfg, "testing",
+ single_variable)) &&
+ GNUNET_CONFIGURATION_get_value_number (uc->cfg, "testing",
+ per_host_variable,
+ &num_per_host))
{
- GNUNET_SCHEDULER_cancel (d->sched,
- d->task);
- d->phase = SP_START_DONE;
+ /* GNUNET_snprintf (cval, sizeof (cval), "%u", */
+ /* ival + ctx->fdnum % num_per_host); */
+ /* value = cval; */
+ GNUNET_break (0); /* FIXME */
}
- if (d->server != NULL)
+ }
+ if (0 == strcmp (option, "UNIXPATH"))
+ {
+ if (GNUNET_YES !=
+ GNUNET_CONFIGURATION_get_value_yesno (uc->cfg, "testing",
+ single_variable))
{
- GNUNET_CORE_disconnect (d->server);
- d->server = NULL;
+ GNUNET_snprintf (uval, sizeof (uval), "%s/%s.sock",
+ uc->service_home, section);
+ value = uval;
}
- /* shutdown ARM process (will also terminate others) */
-#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- _("Terminating peer `%4s'\n"),
- GNUNET_i2s(&d->id));
-#endif
- cc = GNUNET_CLIENT_connect (d->sched,
- "arm",
- d->cfg);
- GNUNET_CLIENT_service_shutdown (cc);
-
- /* state clean up and notifications */
- if (0 != UNLINK (d->cfgfile))
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
- "unlink",
- d->cfgfile);
- if (d->hostname != NULL)
+ else if ((GNUNET_YES ==
+ GNUNET_CONFIGURATION_get_value_number (uc->cfg, "testing",
+ per_host_variable,
+ &num_per_host)) &&
+ (num_per_host > 0))
{
-#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Removing configuration file on remote host `%s'.\n",
- d->hostname);
-#endif
- if (NULL != d->username)
- GNUNET_asprintf (&dst,
- "%s@%s",
- d->username,
- d->hostname);
- else
- dst = GNUNET_strdup (d->hostname);
- d->pid = GNUNET_OS_start_process ("ssh",
- "ssh",
- dst,
- "rm",
- d->cfgfile,
- NULL);
- GNUNET_free (dst);
- if (-1 == d->pid)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Could not start `%s' process to delete configuration file.\n"),
- "ssh");
- GNUNET_free (d->cfgfile);
- GNUNET_free_non_null (d->hostname);
- GNUNET_free_non_null (d->username);
- GNUNET_free (d);
- cb (cb_cls, _("Error cleaning up configuration file.\n"));
- return;
- }
- d->phase = SP_CLEANUP;
- d->dead_cb = cb;
- d->dead_cb_cls = cb_cls;
- d->task
- = GNUNET_SCHEDULER_add_delayed (d->sched,
- GNUNET_CONSTANTS_EXEC_WAIT,
- &start_fsm,
- d);
- return;
+ GNUNET_break(0); /* FIXME */
}
- GNUNET_CONFIGURATION_destroy (d->cfg);
- GNUNET_free (d->cfgfile);
- GNUNET_free_non_null (d->hostname);
- GNUNET_free_non_null (d->username);
- GNUNET_free (d);
- if (NULL != cb)
- cb (cb_cls, NULL);
+ }
+ if (0 == strcmp (option, "HOSTNAME"))
+ {
+ value = (NULL == uc->system->hostname) ? "localhost" : uc->system->hostname;
+ }
+ GNUNET_free (single_variable);
+ GNUNET_free (per_host_variable);
+ GNUNET_CONFIGURATION_set_value_string (uc->cfg, section, option, value);
}
/**
- * Changes the configuration of a GNUnet daemon.
+ * Section iterator to set ACCEPT_FROM/ACCEPT_FROM6 depending on the ip of the
+ * controller in all sections
*
- * @param d the daemon that should be modified
- * @param cfg the new configuration for the daemon
- * @param cb function called once the configuration was changed
- * @param cb_cls closure for cb
+ * @param cls the UpdateContext
+ * @param section name of the section
*/
-void GNUNET_TESTING_daemon_reconfigure (struct GNUNET_TESTING_Daemon *d,
- struct GNUNET_CONFIGURATION_Handle *cfg,
- GNUNET_TESTING_NotifyCompletion cb,
- void * cb_cls)
+static void
+update_config_sections (void *cls,
+ const char *section)
{
- char *arg;
-
- if (d->phase != SP_START_DONE)
+ struct UpdateContext *uc = cls;
+ char **ikeys;
+ char *val;
+ char *ptr;
+ char *orig_allowed_hosts;
+ char *allowed_hosts;
+ char *ACCEPT_FROM_key;
+ uint16_t ikeys_cnt;
+ uint16_t key;
+
+ ikeys_cnt = 0;
+ val = NULL;
+ if (GNUNET_YES == GNUNET_CONFIGURATION_have_value (uc->cfg, section,
+ "TESTING_IGNORE_KEYS"))
+ {
+ GNUNET_assert
+ (GNUNET_YES ==
+ GNUNET_CONFIGURATION_get_value_string (uc->cfg, section,
+ "TESTING_IGNORE_KEYS", &val));
+ ptr = val;
+ for (ikeys_cnt = 0; NULL != (ptr = strstr (ptr, ";")); ikeys_cnt++)
+ ptr++;
+ if (0 == ikeys_cnt)
+ GNUNET_break (0);
+ else
{
- if (NULL != cb)
- cb (cb_cls,
- _("Peer not yet running, can not change configuration at this point."));
- return;
+ ikeys = GNUNET_malloc ((sizeof (char *)) * ikeys_cnt);
+ ptr = val;
+ for (key = 0; key < ikeys_cnt; key++)
+ {
+ ikeys[key] = ptr;
+ ptr = strstr (ptr, ";");
+ *ptr = '\0';
+ ptr++;
+ }
}
-
- /* 1) write configuration to temporary file */
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_write (cfg,
- d->cfgfile))
+ }
+ if (0 != ikeys_cnt)
+ {
+ for (key = 0; key < ikeys_cnt; key++)
{
- if (NULL != cb)
- cb (cb_cls,
- _("Failed to write new configuration to disk."));
- return;
+ if (NULL != strstr (ikeys[key], "ADVERTISED_PORT"))
+ break;
}
-
- /* 2) copy file to remote host (if necessary) */
- if (NULL == d->hostname)
+ if ((key == ikeys_cnt) &&
+ (GNUNET_YES == GNUNET_CONFIGURATION_have_value (uc->cfg, section,
+ "ADVERTISED_PORT")))
{
- /* signal success */
- if (NULL != cb)
- cb (cb_cls, NULL);
- return;
+ if (GNUNET_OK ==
+ GNUNET_CONFIGURATION_get_value_string (uc->cfg, section, "PORT", &ptr))
+ {
+ GNUNET_CONFIGURATION_set_value_string (uc->cfg, section,
+ "ADVERTISED_PORT", ptr);
+ GNUNET_free (ptr);
+ }
}
-#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Copying updated configuration file to remote host `%s'.\n",
- d->hostname);
-#endif
- d->phase = SP_CONFIG_UPDATE;
- if (NULL != d->username)
- GNUNET_asprintf (&arg,
- "%s@%s:%s",
- d->username,
- d->hostname,
- d->cfgfile);
- else
- GNUNET_asprintf (&arg,
- "%s:%s",
- d->hostname,
- d->cfgfile);
- d->pid = GNUNET_OS_start_process ("scp",
- "scp",
- d->cfgfile,
- arg,
- NULL);
- GNUNET_free (arg);
- if (-1 == d->pid)
+ for (key = 0; key < ikeys_cnt; key++)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Could not start `%s' process to copy configuration file.\n"),
- "scp");
- if (NULL != cb)
- cb (cb_cls,
- _("Failed to copy new configuration to remote machine."));
- d->phase = SP_START_DONE;
- return;
+ if (NULL != strstr (ikeys[key], "ACCEPT_FROM"))
+ {
+ GNUNET_free (ikeys);
+ GNUNET_free (val);
+ return;
+ }
}
- d->update_cb = cb;
- d->update_cb_cls = cb_cls;
- d->task
- = GNUNET_SCHEDULER_add_delayed (d->sched,
- GNUNET_CONSTANTS_EXEC_WAIT,
- &start_fsm,
- d);
+ GNUNET_free (ikeys);
+ }
+ GNUNET_free_non_null (val);
+ ACCEPT_FROM_key = "ACCEPT_FROM";
+ if ((NULL != uc->system->controller) &&
+ (NULL != strstr (uc->system->controller, ":"))) /* IPv6 in use */
+ ACCEPT_FROM_key = "ACCEPT_FROM6";
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_string (uc->cfg, section, ACCEPT_FROM_key,
+ &orig_allowed_hosts))
+ {
+ orig_allowed_hosts = GNUNET_strdup ("127.0.0.1;");
+ }
+ if (NULL == uc->system->controller)
+ allowed_hosts = GNUNET_strdup (orig_allowed_hosts);
+ else
+ GNUNET_asprintf (&allowed_hosts, "%s%s;", orig_allowed_hosts,
+ uc->system->controller);
+ GNUNET_free (orig_allowed_hosts);
+ GNUNET_CONFIGURATION_set_value_string (uc->cfg, section, ACCEPT_FROM_key,
+ allowed_hosts);
+ GNUNET_free (allowed_hosts);
}
/**
- * Data kept for each pair of peers that we try
- * to connect.
+ * Create a new configuration using the given configuration as a template;
+ * ports and paths will be modified to select available ports on the local
+ * system. The default configuration will be available in PATHS section under
+ * the option DEFAULTCONFIG after the call. SERVICE_HOME is also set in PATHS
+ * section to the temporary directory specific to this configuration. If we run
+ * out of "*port" numbers, return SYSERR.
+ *
+ * This is primarily a helper function used internally
+ * by 'GNUNET_TESTING_peer_configure'.
+ *
+ * @param system system to use to coordinate resource usage
+ * @param cfg template configuration to update
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error - the configuration will
+ * be incomplete and should not be used there upon
*/
-struct ConnectContext
+int
+GNUNET_TESTING_configuration_create (struct GNUNET_TESTING_System *system,
+ struct GNUNET_CONFIGURATION_Handle *cfg)
{
- /**
- * Testing handle to the first daemon.
- */
- struct GNUNET_TESTING_Daemon *d1;
+ struct UpdateContext uc;
+ char *default_config;
+
+ uc.system = system;
+ uc.cfg = cfg;
+ uc.status = GNUNET_OK;
+ GNUNET_asprintf (&uc.service_home, "%s/%u", system->tmppath,
+ system->path_counter++);
+ GNUNET_asprintf (&default_config, "%s/config", uc.service_home);
+ GNUNET_CONFIGURATION_set_value_string (cfg, "PATHS", "DEFAULTCONFIG",
+ default_config);
+ GNUNET_free (default_config);
+ GNUNET_CONFIGURATION_set_value_string (cfg, "PATHS", "SERVICEHOME",
+ uc.service_home);
+ /* make PORTs and UNIXPATHs unique */
+ GNUNET_CONFIGURATION_iterate (cfg, &update_config, &uc);
+ /* allow connections to services from system controller host */
+ GNUNET_CONFIGURATION_iterate_sections (cfg, &update_config_sections, &uc);
+ /* enable loopback-based connections between peers */
+ GNUNET_CONFIGURATION_set_value_string (cfg,
+ "nat",
+ "USE_LOCALADDR", "YES");
+ GNUNET_free (uc.service_home);
+ return uc.status;
+}
- /**
- * Testing handle to the second daemon.
- */
- struct GNUNET_TESTING_Daemon *d2;
- /**
- * Transport handle to the first daemon.
- */
- struct GNUNET_TRANSPORT_Handle *d1th;
+/**
+ * Configure a GNUnet peer. GNUnet must be installed on the local
+ * system and available in the PATH.
+ *
+ * @param system system to use to coordinate resource usage
+ * @param cfg configuration to use; will be UPDATED (to reflect needed
+ * changes in port numbers and paths)
+ * @param key_number number of the hostkey to use for the peer
+ * @param id identifier for the daemon, will be set, can be NULL
+ * @param emsg set to freshly allocated error message (set to NULL on success),
+ * can be NULL
+ * @return handle to the peer, NULL on error
+ */
+struct GNUNET_TESTING_Peer *
+GNUNET_TESTING_peer_configure (struct GNUNET_TESTING_System *system,
+ struct GNUNET_CONFIGURATION_Handle *cfg,
+ uint32_t key_number,
+ struct GNUNET_PeerIdentity *id,
+ char **emsg)
+{
+ struct GNUNET_TESTING_Peer *peer;
+ struct GNUNET_DISK_FileHandle *fd;
+ char *service_home;
+ char hostkey_filename[128];
+ char *config_filename;
+ char *emsg_;
+ struct GNUNET_CRYPTO_RsaPrivateKey *pk;
+
+ if (NULL != emsg)
+ *emsg = NULL;
+ if (GNUNET_OK != GNUNET_TESTING_configuration_create (system, cfg))
+ {
+ GNUNET_asprintf (&emsg_,
+ _("Failed to create configuration for peer (not enough free ports?)\n"));
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s", emsg_);
+ if (NULL != emsg)
+ *emsg = emsg_;
+ else
+ GNUNET_free (emsg_);
+ return NULL;
+ }
+ if (key_number >= system->total_hostkeys)
+ {
+ GNUNET_asprintf (&emsg_,
+ _("You attempted to create a testbed with more than %u hosts. Please precompute more hostkeys first.\n"),
+ (unsigned int) system->total_hostkeys);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s", emsg_);
+ if (NULL != emsg)
+ *emsg = emsg_;
+ else
+ GNUNET_free (emsg_);
+ return NULL;
+ }
+ pk = NULL;
+ if ((NULL != id) &&
+ (NULL == (pk = GNUNET_TESTING_hostkey_get (system, key_number, id))))
+ {
+ GNUNET_asprintf (&emsg_,
+ _("Failed to initialize hostkey for peer %u\n"),
+ (unsigned int) key_number);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s", emsg_);
+ if (NULL != emsg)
+ *emsg = emsg_;
+ else
+ GNUNET_free (emsg_);
+ return NULL;
+ }
+ if (NULL != pk)
+ GNUNET_CRYPTO_rsa_key_free (pk);
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_CONFIGURATION_get_value_string (cfg, "PATHS",
+ "SERVICEHOME",
+ &service_home));
+ GNUNET_snprintf (hostkey_filename, sizeof (hostkey_filename), "%s/.hostkey",
+ service_home);
+ GNUNET_free (service_home);
+ fd = GNUNET_DISK_file_open (hostkey_filename,
+ GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_WRITE,
+ GNUNET_DISK_PERM_USER_READ
+ | GNUNET_DISK_PERM_USER_WRITE);
+ if (NULL == fd)
+ {
+ GNUNET_break (0);
+ return NULL;
+ }
+ if (GNUNET_TESTING_HOSTKEYFILESIZE !=
+ GNUNET_DISK_file_write (fd, system->hostkeys_data
+ + (key_number * GNUNET_TESTING_HOSTKEYFILESIZE),
+ GNUNET_TESTING_HOSTKEYFILESIZE))
+ {
+ GNUNET_asprintf (&emsg_,
+ _("Failed to write hostkey file for peer %u: %s\n"),
+ (unsigned int) key_number,
+ STRERROR (errno));
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s", emsg_);
+ if (NULL != emsg)
+ *emsg = emsg_;
+ else
+ GNUNET_free (emsg_);
+ GNUNET_DISK_file_close (fd);
+ return NULL;
+ }
+ GNUNET_DISK_file_close (fd);
+ GNUNET_assert (GNUNET_OK ==
+ GNUNET_CONFIGURATION_get_value_string
+ (cfg, "PATHS", "DEFAULTCONFIG", &config_filename));
+ if (GNUNET_OK != GNUNET_CONFIGURATION_write (cfg, config_filename))
+ {
+ GNUNET_asprintf (&emsg_,
+ _("Failed to write configuration file `%s' for peer %u: %s\n"),
+ config_filename,
+ (unsigned int) key_number,
+ STRERROR (errno));
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s", emsg_);
+ if (NULL != emsg)
+ *emsg = emsg_;
+ else
+ GNUNET_free (emsg_);
+ GNUNET_free (config_filename);
+ return NULL;
+ }
+ peer = GNUNET_malloc (sizeof (struct GNUNET_TESTING_Peer));
+ peer->cfgfile = config_filename; /* Free in peer_destroy */
+ peer->main_binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm");
+ peer->system = system;
+ peer->key_number = key_number;
+ return peer;
+}
- /**
- * Transport handle to the second daemon.
- */
- struct GNUNET_TRANSPORT_Handle *d2th;
+/**
+ * Obtain the peer identity from a peer handle.
+ *
+ * @param peer peer handle for which we want the peer's identity
+ * @param id identifier for the daemon, will be set
+ */
+void
+GNUNET_TESTING_peer_get_identity (const struct GNUNET_TESTING_Peer *peer,
+ struct GNUNET_PeerIdentity *id)
+{
+ GNUNET_CRYPTO_rsa_key_free (GNUNET_TESTING_hostkey_get (peer->system,
+ peer->key_number,
+ id));
+}
+
+
+/**
+ * Start the peer.
+ *
+ * @param peer peer to start
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error (i.e. peer already running)
+ */
+int
+GNUNET_TESTING_peer_start (struct GNUNET_TESTING_Peer *peer)
+{
+ if (NULL != peer->main_process)
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+ GNUNET_assert (NULL != peer->cfgfile);
+ peer->main_process = GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, NULL, NULL,
+ peer->main_binary,
+ peer->main_binary,
+ "-c",
+ peer->cfgfile,
+ NULL);
+ if (NULL == peer->main_process)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _("Failed to start `%s': %s\n"),
+ peer->main_binary,
+ STRERROR (errno));
+ return GNUNET_SYSERR;
+ }
+ return GNUNET_OK;
+}
+
+
+/**
+ * Stop the peer.
+ *
+ * @param peer peer to stop
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error (i.e. peer not running)
+ */
+int
+GNUNET_TESTING_peer_stop (struct GNUNET_TESTING_Peer *peer)
+{
+ if (NULL == peer->main_process)
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+ (void) GNUNET_OS_process_kill (peer->main_process, SIGTERM);
+ GNUNET_assert (GNUNET_OK == GNUNET_OS_process_wait (peer->main_process));
+ GNUNET_OS_process_destroy (peer->main_process);
+ peer->main_process = NULL;
+ return GNUNET_OK;
+}
+
+
+/**
+ * Destroy the peer. Releases resources locked during peer configuration.
+ * If the peer is still running, it will be stopped AND a warning will be
+ * printed (users of the API should stop the peer explicitly first).
+ *
+ * @param peer peer to destroy
+ */
+void
+GNUNET_TESTING_peer_destroy (struct GNUNET_TESTING_Peer *peer)
+{
+ if (NULL != peer->main_process)
+ {
+ GNUNET_break (0);
+ GNUNET_TESTING_peer_stop (peer);
+ }
+ GNUNET_free (peer->cfgfile);
+ GNUNET_free (peer->main_binary);
+ GNUNET_free (peer);
+}
+
+
+/**
+ * Start a single peer and run a test using the testing library.
+ * Starts a peer using the given configuration and then invokes the
+ * given callback. This function ALSO initializes the scheduler loop
+ * and should thus be called directly from "main". The testcase
+ * should self-terminate by invoking 'GNUNET_SCHEDULER_shutdown'.
+ *
+ * @param testdir only the directory name without any path. This is used for
+ * all service homes; the directory will be created in a temporary
+ * location depending on the underlying OS
+ * @param cfgfilename name of the configuration file to use;
+ * use NULL to only run with defaults
+ * @param tm main function of the testcase
+ * @param tm_cls closure for 'tm'
+ * @return 0 on success, 1 on error
+ */
+int
+GNUNET_TESTING_peer_run (const char *testdir,
+ const char *cfgfilename,
+ GNUNET_TESTING_TestMain tm,
+ void *tm_cls)
+{
+ return GNUNET_TESTING_service_run (testdir, "arm",
+ cfgfilename, tm, tm_cls);
+}
+
+
+/**
+ * Structure for holding service data
+ */
+struct ServiceContext
+{
/**
- * Function to call once we are done (or have timed out).
+ * The configuration of the peer in which the service is run
*/
- GNUNET_TESTING_NotifyCompletion cb;
+ const struct GNUNET_CONFIGURATION_Handle *cfg;
/**
- * Closure for "nb".
+ * Callback to signal service startup
*/
- void *cb_cls;
-
+ GNUNET_TESTING_TestMain tm;
+
/**
- * Transmit handle for our request for transmission
- * (as given to d2 asking to talk to d1).
+ * The peer in which the service is run.
*/
- struct GNUNET_CORE_TransmitHandle *ntr;
+ struct GNUNET_TESTING_Peer *peer;
/**
- * When should this operation be complete (or we must trigger
- * a timeout).
+ * Closure for the above callback
*/
- struct GNUNET_TIME_Absolute timeout;
-
+ void *tm_cls;
};
/**
- * Notify callback about success or failure of the attempt
- * to connect the two peers
- *
- * @param cls our "struct ConnectContext" (freed)
- * @param tc reason tells us if we succeeded or failed
+ * Callback to be called when SCHEDULER has been started
+ *
+ * @param cls the ServiceContext
+ * @param tc the TaskContext
*/
static void
-notify_connect_result (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+service_run_main (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- struct ConnectContext *ctx = cls;
+ struct ServiceContext *sc = cls;
- if (ctx->cb != NULL)
- {
- if ((tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT) != 0)
- ctx->cb (ctx->cb_cls, _("Peers failed to connect"));
- else
- ctx->cb (ctx->cb_cls, NULL);
- }
- GNUNET_free (ctx);
+ sc->tm (sc->tm_cls, sc->cfg, sc->peer);
}
/**
- * Success, connection is up. Signal client our success.
+ * Start a single service (no ARM, except of course if the given
+ * service name is 'arm') and run a test using the testing library.
+ * Starts a service using the given configuration and then invokes the
+ * given callback. This function ALSO initializes the scheduler loop
+ * and should thus be called directly from "main". The testcase
+ * should self-terminate by invoking 'GNUNET_SCHEDULER_shutdown'.
*
- * @param cls our "struct ConnectContext"
- * @param size number of bytes available in buf
- * @param buf where to copy the message, NULL on error
- * @return number of bytes copied to buf
+ * This function is useful if the testcase is for a single service
+ * and if that service doesn't itself depend on other services.
+ *
+ * @param testdir only the directory name without any path. This is used for
+ * all service homes; the directory will be created in a temporary
+ * location depending on the underlying OS
+ * @param service_name name of the service to run
+ * @param cfgfilename name of the configuration file to use;
+ * use NULL to only run with defaults
+ * @param tm main function of the testcase
+ * @param tm_cls closure for 'tm'
+ * @return 0 on success, 1 on error
*/
-static size_t
-transmit_ready (void *cls, size_t size, void *buf)
+int
+GNUNET_TESTING_service_run (const char *testdir,
+ const char *service_name,
+ const char *cfgfilename,
+ GNUNET_TESTING_TestMain tm,
+ void *tm_cls)
{
- struct ConnectContext *ctx = cls;
-
-#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Core notified us about readiness to transmit message, connection must be up!\n");
-#endif
- ctx->ntr = NULL;
- GNUNET_TRANSPORT_disconnect (ctx->d1th);
- ctx->d1th = NULL;
- GNUNET_TRANSPORT_disconnect (ctx->d2th);
- ctx->d2th = NULL;
- GNUNET_SCHEDULER_add_continuation (ctx->d1->sched,
- ¬ify_connect_result,
- ctx,
- (buf == NULL) ?
- GNUNET_SCHEDULER_REASON_TIMEOUT :
- GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+ struct ServiceContext sc;
+ struct GNUNET_TESTING_System *system;
+ struct GNUNET_TESTING_Peer *peer;
+ struct GNUNET_CONFIGURATION_Handle *cfg;
+ char *binary;
+
+ GNUNET_log_setup (testdir, "WARNING", NULL);
+ system = GNUNET_TESTING_system_create (testdir, "127.0.0.1", NULL);
+ if (NULL == system)
+ return 1;
+ cfg = GNUNET_CONFIGURATION_create ();
+ if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg, cfgfilename))
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Failed to load configuration from %s\n"), cfgfilename);
+ GNUNET_CONFIGURATION_destroy (cfg);
+ GNUNET_TESTING_system_destroy (system, GNUNET_YES);
+ return 1;
+ }
+ peer = GNUNET_TESTING_peer_configure (system, cfg, 0, NULL, NULL);
+ if (NULL == peer)
+ {
+ GNUNET_CONFIGURATION_destroy (cfg);
+ hostkeys_unload (system);
+ GNUNET_TESTING_system_destroy (system, GNUNET_YES);
+ return 1;
+ }
+ GNUNET_free (peer->main_binary);
+ GNUNET_asprintf (&binary, "gnunet-service-%s", service_name);
+ peer->main_binary = GNUNET_OS_get_libexec_binary_path (binary);
+ GNUNET_free (binary);
+ if (GNUNET_OK != GNUNET_TESTING_peer_start (peer))
+ {
+ GNUNET_TESTING_peer_destroy (peer);
+ GNUNET_CONFIGURATION_destroy (cfg);
+ GNUNET_TESTING_system_destroy (system, GNUNET_YES);
+ return 1;
+ }
+ sc.cfg = cfg;
+ sc.tm = tm;
+ sc.tm_cls = tm_cls;
+ sc.peer = peer;
+ GNUNET_SCHEDULER_run (&service_run_main, &sc); /* Scheduler loop */
+ if ((NULL != peer->main_process) &&
+ (GNUNET_OK != GNUNET_TESTING_peer_stop (peer)))
+ {
+ GNUNET_TESTING_peer_destroy (peer);
+ GNUNET_CONFIGURATION_destroy (cfg);
+ GNUNET_TESTING_system_destroy (system, GNUNET_YES);
+ return 1;
+ }
+ GNUNET_TESTING_peer_destroy (peer);
+ GNUNET_CONFIGURATION_destroy (cfg);
+ GNUNET_TESTING_system_destroy (system, GNUNET_YES);
return 0;
}
/**
- * Receive the HELLO from one peer, give it to the other
- * and ask them to connect.
- *
- * @param cls "struct ConnectContext"
- * @param latency how fast is the connection
- * @param peer ID of peer giving us the HELLO
- * @param message HELLO message of peer
- */
-static void
-process_hello (void *cls,
- struct GNUNET_TIME_Relative latency,
- const struct GNUNET_PeerIdentity *peer,
- const struct GNUNET_MessageHeader *message)
-{
- struct ConnectContext *ctx = cls;
-
- if (peer == NULL)
- {
- /* signal error */
- GNUNET_TRANSPORT_disconnect (ctx->d1th);
- GNUNET_TRANSPORT_disconnect (ctx->d2th);
- if (NULL != ctx->cb)
- ctx->cb (ctx->cb_cls,
- _("Failed to receive `HELLO' from peer\n"));
- GNUNET_free (ctx);
- return;
- }
-#if DEBUG_TESTING
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Received `%s' from transport service of `%4s'\n",
- "HELLO", GNUNET_i2s (peer));
-#endif
- GNUNET_assert (message != NULL);
- GNUNET_TRANSPORT_offer_hello (ctx->d2th, message);
- ctx->ntr
- = GNUNET_CORE_notify_transmit_ready (ctx->d2->server,
- 0,
- GNUNET_TIME_absolute_get_remaining (ctx->timeout),
- &ctx->d1->id,
- sizeof (struct GNUNET_MessageHeader),
- &transmit_ready, ctx);
-}
-
-
-/**
- * Establish a connection between two GNUnet daemons.
+ * Sometimes we use the binary name to determine which specific
+ * test to run. In those cases, the string after the last "_"
+ * in 'argv[0]' specifies a string that determines the configuration
+ * file or plugin to use.
+ *
+ * This function returns the respective substring, taking care
+ * of issues such as binaries ending in '.exe' on W32.
*
- * @param d1 handle for the first daemon
- * @param d2 handle for the second daemon
- * @param timeout how long is the connection attempt
- * allowed to take?
- * @param cb function to call at the end
- * @param cb_cls closure for cb
+ * @param argv0 the name of the binary
+ * @return string between the last '_' and the '.exe' (or the end of the string),
+ * NULL if argv0 has no '_'
*/
-void GNUNET_TESTING_daemons_connect (struct GNUNET_TESTING_Daemon *d1,
- struct GNUNET_TESTING_Daemon *d2,
- struct GNUNET_TIME_Relative timeout,
- GNUNET_TESTING_NotifyCompletion cb,
- void *cb_cls)
+char *
+GNUNET_TESTING_get_testname_from_underscore (const char *argv0)
{
- struct ConnectContext *ctx;
-
- if ( (d1->server == NULL) ||
- (d2->server == NULL) )
- {
- if (NULL != cb)
- cb (cb_cls, _("Peers are not fully running yet, can not connect!\n"));
- return;
- }
- ctx = GNUNET_malloc (sizeof(struct ConnectContext));
- ctx->d1 = d1;
- ctx->d2 = d2;
- ctx->timeout = GNUNET_TIME_relative_to_absolute (timeout);
- ctx->cb = cb;
- ctx->cb_cls = cb_cls;
- ctx->d1th = GNUNET_TRANSPORT_connect (d1->sched,
- d1->cfg,
- d1,
- NULL, NULL, NULL);
- if (ctx->d1th == NULL)
- {
- GNUNET_free (ctx);
- if (NULL != cb)
- cb (cb_cls, _("Failed to connect to transport service!\n"));
- return;
- }
- ctx->d2th = GNUNET_TRANSPORT_connect (d2->sched,
- d2->cfg,
- d2,
- NULL, NULL, NULL);
- if (ctx->d2th == NULL)
- {
- GNUNET_TRANSPORT_disconnect (ctx->d1th);
- GNUNET_free (ctx);
- if (NULL != cb)
- cb (cb_cls, _("Failed to connect to transport service!\n"));
- return;
- }
- GNUNET_TRANSPORT_get_hello (ctx->d1th,
- timeout,
- &process_hello,
- ctx);
+ size_t slen = strlen (argv0) + 1;
+ char sbuf[slen];
+ char *ret;
+ char *dot;
+
+ memcpy (sbuf, argv0, slen);
+ ret = strrchr (sbuf, '_');
+ if (NULL == ret)
+ return NULL;
+ ret++; /* skip underscore */
+ dot = strchr (ret, '.');
+ if (NULL != dot)
+ *dot = '\0';
+ return GNUNET_strdup (ret);
}
projects / oweals / gnunet.git / blobdiff