testing.c File Reference

convenience API for writing testcases for GNUnet Many testcases need to start and stop a peer/service and this library is supposed to make that easier for TESTCASES. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_arm_service.h"
#include "gnunet_testing_lib.h"

Include dependency graph for testing.c:

Go to the source code of this file.

Data Structures
struct	SharedServiceInstance
struct	SharedService
	The structure for identifying a shared service. More...
struct	GNUNET_TESTING_System
	Handle for a system on which GNUnet peers are executed; a system is used for reserving unique paths and ports. More...
struct	GNUNET_TESTING_Peer
	Handle for a GNUnet peer controlled by testing. More...
struct	UpdateContext
	Closure for update_rel_sum() and update_abs_sum(). More...
struct	ServiceContext
	Structure for holding service data. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from(kind, "testing-api", __VA_ARGS__)
#define	PIPE_CONTROL   GNUNET_NO
	We need pipe control only on WINDOWS. More...
#define	LOW_PORT   12000
	Lowest port used for GNUnet testing. More...
#define	HIGH_PORT   56000
	Highest port used for GNUnet testing. More...

Functions
static int	hostkeys_load (struct GNUNET_TESTING_System *system)
	Testing includes a number of pre-created hostkeys for faster peer startup. More...
static void	hostkeys_unload (struct GNUNET_TESTING_System *system)
	Function to remove the loaded hostkeys. More...
static void	cfg_copy_iterator (void *cls, const char *section, const char *option, const char *value)
	Function to iterate over options. More...
struct GNUNET_TESTING_System *	GNUNET_TESTING_system_create_with_portrange (const char *testdir, const char *trusted_ip, const char *hostname, const struct GNUNET_TESTING_SharedService *shared_services, uint16_t lowport, uint16_t highport)
	Create a system handle. More...
struct GNUNET_TESTING_System *	GNUNET_TESTING_system_create (const char *testdir, const char *trusted_ip, const char *hostname, const struct GNUNET_TESTING_SharedService *shared_services)
	Create a system handle. More...
static void	cleanup_shared_service_instance (struct SharedServiceInstance *i)
static int	start_shared_service_instance (struct SharedServiceInstance *i)
static void	stop_shared_service_instance (struct SharedServiceInstance *i)
void	GNUNET_TESTING_system_destroy (struct GNUNET_TESTING_System *system, int remove_paths)
	Free system resources. More...
uint16_t	GNUNET_TESTING_reserve_port (struct GNUNET_TESTING_System *system)
	Reserve a TCP or UDP port for a peer. More...
void	GNUNET_TESTING_release_port (struct GNUNET_TESTING_System *system, uint16_t port)
	Release reservation of a TCP or UDP port for a peer (used during GNUNET_TESTING_peer_destroy()). More...
struct GNUNET_CRYPTO_EddsaPrivateKey *	GNUNET_TESTING_hostkey_get (const struct GNUNET_TESTING_System *system, uint32_t key_number, struct GNUNET_PeerIdentity *id)
	Testing includes a number of pre-created hostkeys for faster peer startup. More...
static void	update_config (void *cls, const char *section, const char *option, const char *value)
	Function to iterate over options. More...
static void	update_config_sections (void *cls, const char *section)
	Section iterator to set ACCEPT_FROM/ACCEPT_FROM6 to include the address of 'trusted_hosts' in all sections. More...
static struct SharedServiceInstance *	associate_shared_service (struct GNUNET_TESTING_System *system, struct SharedService *ss, struct GNUNET_CONFIGURATION_Handle *cfg)
static int	GNUNET_TESTING_configuration_create_ (struct GNUNET_TESTING_System *system, struct GNUNET_CONFIGURATION_Handle *cfg, uint16_t **ports, unsigned int *nports)
	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. More...
int	GNUNET_TESTING_configuration_create (struct GNUNET_TESTING_System *system, struct GNUNET_CONFIGURATION_Handle *cfg)
	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. More...
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)
	Configure a GNUnet peer. More...
void	GNUNET_TESTING_peer_get_identity (struct GNUNET_TESTING_Peer *peer, struct GNUNET_PeerIdentity *id)
	Obtain the peer identity from a peer handle. More...
int	GNUNET_TESTING_peer_start (struct GNUNET_TESTING_Peer *peer)
	Start the peer. More...
int	GNUNET_TESTING_peer_kill (struct GNUNET_TESTING_Peer *peer)
	Sends SIGTERM to the peer's main process. More...
int	GNUNET_TESTING_peer_wait (struct GNUNET_TESTING_Peer *peer)
	Waits for a peer to terminate. More...
int	GNUNET_TESTING_peer_stop (struct GNUNET_TESTING_Peer *peer)
	Stop the peer. More...
static void	disconn_status (void *cls, int connected)
	Function called whenever we connect to or disconnect from ARM. More...
int	GNUNET_TESTING_peer_stop_async (struct GNUNET_TESTING_Peer *peer, GNUNET_TESTING_PeerStopCallback cb, void *cb_cls)
	Stop a peer asynchronously using ARM API. More...
void	GNUNET_TESTING_peer_stop_async_cancel (struct GNUNET_TESTING_Peer *peer)
	Cancel a previous asynchronous peer stop request. More...
void	GNUNET_TESTING_peer_destroy (struct GNUNET_TESTING_Peer *peer)
	Destroy the peer. More...
int	GNUNET_TESTING_peer_run (const char *testdir, const char *cfgfilename, GNUNET_TESTING_TestMain tm, void *tm_cls)
	Start a single peer and run a test using the testing library. More...
static void	service_run_main (void *cls)
	Callback to be called when SCHEDULER has been started. More...
int	GNUNET_TESTING_service_run (const char *testdir, const char *service_name, const char *cfgfilename, GNUNET_TESTING_TestMain tm, void *tm_cls)
	Start a single service (no ARM, except of course if the given service name is 'arm') and run a test using the testing library. More...
char *	GNUNET_TESTING_get_testname_from_underscore (const char *argv0)
	Sometimes we use the binary name to determine which specific test to run. More...

Detailed Description

convenience API for writing testcases for GNUnet 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 (or internal use of the testbed).

Author

Christian Grothoff

Definition in file testing.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from(kind, "testing-api", __VA_ARGS__)

Definition at line 37 of file testing.c.

Referenced by GNUNET_TESTING_hostkey_get(), GNUNET_TESTING_release_port(), GNUNET_TESTING_reserve_port(), GNUNET_TESTING_service_run(), hostkeys_load(), and stop_shared_service_instance().

PIPE_CONTROL

#define PIPE_CONTROL   GNUNET_NO

We need pipe control only on WINDOWS.

Definition at line 43 of file testing.c.

Referenced by GNUNET_TESTING_peer_start(), and start_shared_service_instance().

LOW_PORT

#define LOW_PORT   12000

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).

Definition at line 52 of file testing.c.

Referenced by GNUNET_TESTING_system_create().

HIGH_PORT

#define HIGH_PORT   56000

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).

Definition at line 59 of file testing.c.

Referenced by GNUNET_TESTING_system_create().

Function Documentation

hostkeys_load()

static int hostkeys_load ( struct GNUNET_TESTING_System *  system )

static

Testing includes a number of pre-created hostkeys for faster peer startup.

This function loads such keys into memory from a file.

Parameters

system

the testing system handle

Returns

GNUNET_OK on success; GNUNET_SYSERR on error

Definition at line 248 of file testing.c.

References _, GNUNET_DISK_FileHandle::fd, filename, fs, GNUNET_asprintf(), GNUNET_assert, GNUNET_DISK_file_close(), GNUNET_DISK_file_map(), GNUNET_DISK_file_open(), GNUNET_DISK_file_size(), GNUNET_DISK_file_test(), GNUNET_DISK_MAP_TYPE_READ, GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_strerror_file, GNUNET_OK, GNUNET_OS_installation_get_path(), GNUNET_OS_IPK_DATADIR, GNUNET_SYSERR, GNUNET_TESTING_HOSTKEYFILESIZE, GNUNET_YES, GNUNET_TESTING_System::hostkeys_data, LOG, GNUNET_TESTING_System::map, and GNUNET_TESTING_System::total_hostkeys.

Referenced by GNUNET_TESTING_system_create_with_portrange().

{
  uint64_t fs;
  char *data_dir;
  char *filename;
  struct GNUNET_DISK_FileHandle *fd;

  GNUNET_assert(NULL == system->hostkeys_data);
  data_dir = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_DATADIR);
  GNUNET_asprintf(&filename, "%s/testing_hostkeys.ecc", 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;
    }
  fd = GNUNET_DISK_file_open(filename,
                             GNUNET_DISK_OPEN_READ,
                             GNUNET_DISK_PERM_NONE);
  if (NULL == fd)
    {
      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "open", filename);
      GNUNET_free(filename);
      return GNUNET_SYSERR;
    }
  GNUNET_free(filename);
  system->hostkeys_data =
    GNUNET_DISK_file_map(fd, &system->map, GNUNET_DISK_MAP_TYPE_READ, fs);
  GNUNET_DISK_file_close(fd);
  if (NULL == system->hostkeys_data)
    return GNUNET_SYSERR;
  system->total_hostkeys = fs / GNUNET_TESTING_HOSTKEYFILESIZE;
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

hostkeys_unload()

static void hostkeys_unload ( struct GNUNET_TESTING_System *  system )

static

Function to remove the loaded hostkeys.

Parameters

system

the testing system handle

Definition at line 311 of file testing.c.

References GNUNET_break, GNUNET_DISK_file_unmap(), GNUNET_TESTING_System::hostkeys_data, GNUNET_TESTING_System::map, and GNUNET_TESTING_System::total_hostkeys.

Referenced by GNUNET_TESTING_service_run(), and GNUNET_TESTING_system_destroy().

{
  GNUNET_break(NULL != system->hostkeys_data);
  system->hostkeys_data = NULL;
  GNUNET_DISK_file_unmap(system->map);
  system->map = NULL;
  system->hostkeys_data = NULL;
  system->total_hostkeys = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cfg_copy_iterator()

static void cfg_copy_iterator ( void *  cls, const char *  section, const char *  option, const char *  value  )

static

Function to iterate over options.

Parameters

cls	closure
section	name of the section
option	name of the option
value	value of the option

Definition at line 331 of file testing.c.

References GNUNET_CONFIGURATION_set_value_string().

Referenced by associate_shared_service(), and GNUNET_TESTING_system_create_with_portrange().

{
  struct GNUNET_CONFIGURATION_Handle *cfg2 = cls;

  GNUNET_CONFIGURATION_set_value_string(cfg2, section, option, value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_shared_service_instance()

static void cleanup_shared_service_instance ( struct SharedServiceInstance *  i )

static

Definition at line 465 of file testing.c.

References SharedServiceInstance::cfg_fn, GNUNET_break, GNUNET_free, GNUNET_free_non_null, SharedServiceInstance::n_refs, SharedServiceInstance::port_str, SharedServiceInstance::proc, and SharedServiceInstance::unix_sock.

Referenced by associate_shared_service(), and GNUNET_TESTING_system_destroy().

{
  if (NULL != i->cfg_fn)
    {
      (void)unlink(i->cfg_fn);
      GNUNET_free(i->cfg_fn);
    }
  GNUNET_free_non_null(i->unix_sock);
  GNUNET_free_non_null(i->port_str);
  GNUNET_break(NULL == i->proc);
  GNUNET_break(0 == i->n_refs);
  GNUNET_free(i);
}

Here is the caller graph for this function:

start_shared_service_instance()

static int start_shared_service_instance ( struct SharedServiceInstance *  i )

static

Definition at line 481 of file testing.c.

References SharedServiceInstance::cfg_fn, GNUNET_asprintf(), GNUNET_assert, GNUNET_free, GNUNET_OK, GNUNET_OS_get_libexec_binary_path(), GNUNET_OS_INHERIT_STD_OUT_AND_ERR, GNUNET_OS_start_process(), GNUNET_SYSERR, PIPE_CONTROL, SharedServiceInstance::proc, SharedService::sname, and SharedServiceInstance::ss.

Referenced by GNUNET_TESTING_peer_start().

{
  char *binary;
  char *libexec_binary;

  GNUNET_assert(NULL == i->proc);
  GNUNET_assert(NULL != i->cfg_fn);
  (void)GNUNET_asprintf(&binary, "gnunet-service-%s", i->ss->sname);
  libexec_binary = GNUNET_OS_get_libexec_binary_path(binary);
  GNUNET_free(binary);
  i->proc = GNUNET_OS_start_process(PIPE_CONTROL,
                                    GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
                                    NULL,
                                    NULL,
                                    NULL,
                                    libexec_binary,
                                    libexec_binary,
                                    "-c",
                                    i->cfg_fn,
                                    NULL);
  GNUNET_free(libexec_binary);
  if (NULL == i->proc)
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

stop_shared_service_instance()

static void stop_shared_service_instance ( struct SharedServiceInstance *  i )

static

Definition at line 509 of file testing.c.

References GNUNET_break, GNUNET_ERROR_TYPE_WARNING, GNUNET_OS_process_destroy(), GNUNET_OS_process_kill(), GNUNET_OS_process_wait(), GNUNET_TERM_SIG, LOG, SharedServiceInstance::n_refs, SharedServiceInstance::proc, SharedService::sname, and SharedServiceInstance::ss.

Referenced by GNUNET_TESTING_peer_kill(), and GNUNET_TESTING_system_destroy().

{
  GNUNET_break(0 == i->n_refs);
  if (0 != GNUNET_OS_process_kill(i->proc, GNUNET_TERM_SIG))
    LOG(GNUNET_ERROR_TYPE_WARNING,
        "Killing shared service instance (%s) failed\n",
        i->ss->sname);
  (void)GNUNET_OS_process_wait(i->proc);
  GNUNET_OS_process_destroy(i->proc);
  i->proc = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_config()

static void update_config ( void *  cls, const char *  section, const char *  option, const char *  value  )

static

Function to iterate over options.

Copies the options to the target configuration, updating PORT values as needed.

Parameters

cls	the UpdateContext
section	name of the section
option	name of the option
value	value of the option

Definition at line 782 of file testing.c.

References UpdateContext::cfg, GNUNET_array_append, GNUNET_asprintf(), GNUNET_break, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_free, UpdateContext::gnunet_home, GNUNET_OK, GNUNET_snprintf(), GNUNET_SYSERR, GNUNET_TESTING_reserve_port(), GNUNET_YES, GNUNET_TESTING_System::hostname, UpdateContext::nports, PATH_MAX, UpdateContext::ports, UpdateContext::status, UpdateContext::system, and uc.

Referenced by GNUNET_TESTING_configuration_create_().

{
  struct UpdateContext *uc = cls;
  unsigned int ival;
  char cval[12];
  char uval[PATH_MAX];
  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)))
        {
          new_port = GNUNET_TESTING_reserve_port(uc->system);
          if (0 == new_port)
            {
              uc->status = GNUNET_SYSERR;
              GNUNET_free(single_variable);
              GNUNET_free(per_host_variable);
              return;
            }
          GNUNET_snprintf(cval, sizeof(cval), "%u", new_port);
          value = cval;
          GNUNET_array_append(uc->ports, uc->nports, new_port);
        }
      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_snprintf (cval, sizeof (cval), "%u", */
          /*                  ival + ctx->fdnum % num_per_host); */
          /* value = cval; */
          GNUNET_break(0); /* FIXME */
        }
    }
  if (0 == strcmp(option, "UNIXPATH"))
    {
      if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_yesno(uc->cfg,
                                                             "testing",
                                                             single_variable))
        {
          GNUNET_snprintf(uval,
                          sizeof(uval),
                          "%s/%s.sock",
                          uc->gnunet_home,
                          section);
          value = uval;
        }
      else if ((GNUNET_YES ==
                GNUNET_CONFIGURATION_get_value_number(uc->cfg,
                                                      "testing",
                                                      per_host_variable,
                                                      &num_per_host)) &&
               (num_per_host > 0))
        {
          GNUNET_break(0); /* FIXME */
        }
    }
  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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_config_sections()

static void update_config_sections ( void *  cls, const char *  section  )

static

Section iterator to set ACCEPT_FROM/ACCEPT_FROM6 to include the address of 'trusted_hosts' in all sections.

Parameters

cls	the UpdateContext
section	name of the section

Definition at line 879 of file testing.c.

References UpdateContext::cfg, GNUNET_asprintf(), GNUNET_assert, GNUNET_break, GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_have_value(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_free, GNUNET_free_non_null, GNUNET_malloc, GNUNET_OK, GNUNET_strdup, GNUNET_YES, key, UpdateContext::system, GNUNET_TESTING_System::trusted_ip, and uc.

Referenced by GNUNET_TESTING_configuration_create_().

{
  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;
  /* Ignore certain options from sections.  See
     https://gnunet.org/bugs/view.php?id=2476 */
  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
        {
          ikeys = GNUNET_malloc((sizeof(char *)) * ikeys_cnt);
          ptr = val;
          for (key = 0; key < ikeys_cnt; key++)
            {
              ikeys[key] = ptr;
              ptr = strstr(ptr, ";");
              GNUNET_assert(NULL != ptr); /* worked just before... */
              *ptr = '\0';
              ptr++;
            }
        }
    }
  if (0 != ikeys_cnt)
    {
      for (key = 0; key < ikeys_cnt; key++)
        {
          if (NULL != strstr(ikeys[key], "ADVERTISED_PORT"))
            break;
        }
      if ((key == ikeys_cnt) &&
          (GNUNET_YES ==
           GNUNET_CONFIGURATION_have_value(uc->cfg, section, "ADVERTISED_PORT")))
        {
          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);
            }
        }
      for (key = 0; key < ikeys_cnt; key++)
        {
          if (NULL != strstr(ikeys[key], "ACCEPT_FROM"))
            {
              GNUNET_free(ikeys);
              GNUNET_free(val);
              return;
            }
        }
      GNUNET_free(ikeys);
    }
  GNUNET_free_non_null(val);
  ACCEPT_FROM_key = "ACCEPT_FROM";
  if ((NULL != uc->system->trusted_ip) &&
      (NULL != strstr(uc->system->trusted_ip, ":")))  /* 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->trusted_ip)
    allowed_hosts = GNUNET_strdup(orig_allowed_hosts);
  else
    GNUNET_asprintf(&allowed_hosts,
                    "%s%s;",
                    orig_allowed_hosts,
                    uc->system->trusted_ip);
  GNUNET_free(orig_allowed_hosts);
  GNUNET_CONFIGURATION_set_value_string(uc->cfg,
                                        section,
                                        ACCEPT_FROM_key,
                                        allowed_hosts);
  GNUNET_free(allowed_hosts);
}

Here is the call graph for this function:

Here is the caller graph for this function:

associate_shared_service()

static struct SharedServiceInstance* associate_shared_service ( struct GNUNET_TESTING_System *  system, struct SharedService *  ss, struct GNUNET_CONFIGURATION_Handle *  cfg  )

static

Definition at line 985 of file testing.c.

References SharedService::cfg, cfg_copy_iterator(), SharedServiceInstance::cfg_fn, cleanup_shared_service_instance(), GNUNET_array_append, GNUNET_asprintf(), GNUNET_assert, GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_dup(), GNUNET_CONFIGURATION_iterate_section_values(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_CONFIGURATION_write(), GNUNET_free, GNUNET_new, GNUNET_SYSERR, GNUNET_TESTING_reserve_port(), SharedService::instances, SharedService::n_instances, SharedService::n_peers, port, SharedServiceInstance::port_str, SharedService::share, SharedService::sname, SharedServiceInstance::ss, GNUNET_TESTING_System::tmppath, and SharedServiceInstance::unix_sock.

Referenced by GNUNET_TESTING_peer_configure().

{
  struct SharedServiceInstance *i;
  struct GNUNET_CONFIGURATION_Handle *temp;
  char *gnunet_home;
  uint32_t port;

  ss->n_peers++;
  if (((0 == ss->share) && (NULL == ss->instances)) ||
      ((0 != ss->share) &&
       (ss->n_instances < ((ss->n_peers + ss->share - 1) / ss->share))))
    {
      i = GNUNET_new(struct SharedServiceInstance);
      i->ss = ss;
      (void)GNUNET_asprintf(&gnunet_home,
                            "%s/shared/%s/%u",
                            system->tmppath,
                            ss->sname,
                            ss->n_instances);
      (void)GNUNET_asprintf(&i->unix_sock, "%s/sock", gnunet_home);
      port = GNUNET_TESTING_reserve_port(system);
      if (0 == port)
        {
          GNUNET_free(gnunet_home);
          cleanup_shared_service_instance(i);
          return NULL;
        }
      GNUNET_array_append(ss->instances, ss->n_instances, i);
      temp = GNUNET_CONFIGURATION_dup(ss->cfg);
      (void)GNUNET_asprintf(&i->port_str, "%u", port);
      (void)GNUNET_asprintf(&i->cfg_fn, "%s/config", gnunet_home);
      GNUNET_CONFIGURATION_set_value_string(temp,
                                            "PATHS",
                                            "GNUNET_HOME",
                                            gnunet_home);
      GNUNET_free(gnunet_home);
      GNUNET_CONFIGURATION_set_value_string(temp,
                                            ss->sname,
                                            "UNIXPATH",
                                            i->unix_sock);
      GNUNET_CONFIGURATION_set_value_string(temp,
                                            ss->sname,
                                            "PORT",
                                            i->port_str);
      if (GNUNET_SYSERR == GNUNET_CONFIGURATION_write(temp, i->cfg_fn))
        {
          GNUNET_CONFIGURATION_destroy(temp);
          cleanup_shared_service_instance(i);
          return NULL;
        }
      GNUNET_CONFIGURATION_destroy(temp);
    }
  else
    {
      GNUNET_assert(NULL != ss->instances);
      GNUNET_assert(0 < ss->n_instances);
      i = ss->instances[ss->n_instances - 1];
    }
  GNUNET_CONFIGURATION_iterate_section_values(ss->cfg,
                                              ss->sname,
                                              &cfg_copy_iterator,
                                              cfg);
  GNUNET_CONFIGURATION_set_value_string(cfg,
                                        ss->sname,
                                        "UNIXPATH",
                                        i->unix_sock);
  GNUNET_CONFIGURATION_set_value_string(cfg, ss->sname, "PORT", i->port_str);
  return i;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_configuration_create_()

static int GNUNET_TESTING_configuration_create_ ( struct GNUNET_TESTING_System *  system, struct GNUNET_CONFIGURATION_Handle *  cfg, uint16_t **  ports, unsigned int *  nports  )

static

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. GNUNET_HOME is also set in PATHS section to the temporary directory specific to this configuration. If we run out of "*port" numbers, return GNUNET_SYSERR.

This is primarily a helper function used internally by 'GNUNET_TESTING_peer_configure'.

Parameters

system	system to use to coordinate resource usage
cfg	template configuration to update
ports	array with port numbers used in the created configuration. Will be updated upon successful return. Can be NULL
nports	the size of the `ports' array. Will be updated.

Returns

GNUNET_OK on success, GNUNET_SYSERR on error - the configuration will be incomplete and should not be used there upon

Definition at line 1078 of file testing.c.

References cfg, UpdateContext::cfg, GNUNET_asprintf(), GNUNET_CONFIGURATION_iterate(), GNUNET_CONFIGURATION_iterate_sections(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_free, GNUNET_free_non_null, UpdateContext::gnunet_home, GNUNET_OK, UpdateContext::nports, GNUNET_TESTING_System::path_counter, UpdateContext::ports, UpdateContext::status, UpdateContext::system, GNUNET_TESTING_System::tmppath, update_config(), and update_config_sections().

Referenced by GNUNET_TESTING_configuration_create(), and GNUNET_TESTING_peer_configure().

{
  struct UpdateContext uc;
  char *default_config;

  uc.system = system;
  uc.cfg = cfg;
  uc.status = GNUNET_OK;
  uc.ports = NULL;
  uc.nports = 0;
  GNUNET_asprintf(&uc.gnunet_home,
                  "%s/%u",
                  system->tmppath,
                  system->path_counter++);
  GNUNET_asprintf(&default_config, "%s/config", uc.gnunet_home);
  GNUNET_CONFIGURATION_set_value_string(cfg,
                                        "PATHS",
                                        "DEFAULTCONFIG",
                                        default_config);
  GNUNET_CONFIGURATION_set_value_string(cfg, "arm", "CONFIG", default_config);
  GNUNET_free(default_config);
  GNUNET_CONFIGURATION_set_value_string(cfg,
                                        "PATHS",
                                        "GNUNET_HOME",
                                        uc.gnunet_home);
  /* make PORTs and UNIXPATHs unique */
  GNUNET_CONFIGURATION_iterate(cfg, &update_config, &uc);
  /* allow connections to services from system trusted_ip 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.gnunet_home);
  if ((NULL != ports) && (NULL != nports))
    {
      *ports = uc.ports;
      *nports = uc.nports;
    }
  else
    GNUNET_free_non_null(uc.ports);
  return uc.status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

disconn_status()

static void disconn_status ( void *  cls, int  connected  )

static

Function called whenever we connect to or disconnect from ARM.

Parameters

cls	closure
connected	GNUNET_YES if connected, GNUNET_NO if disconnected, GNUNET_SYSERR on error.

Definition at line 1478 of file testing.c.

References GNUNET_TESTING_Peer::ah, GNUNET_TESTING_Peer::cb, GNUNET_TESTING_Peer::cb_cls, GNUNET_ARM_disconnect(), GNUNET_break, GNUNET_OK, GNUNET_SYSERR, GNUNET_TESTING_peer_kill(), GNUNET_TESTING_peer_wait(), GNUNET_YES, and peer.

Referenced by GNUNET_TESTING_peer_stop_async().

{
  struct GNUNET_TESTING_Peer *peer = cls;

  if (GNUNET_SYSERR == connected)
    {
      peer->cb(peer->cb_cls, peer, connected);
      return;
    }
  if (GNUNET_YES == connected)
    {
      GNUNET_break(GNUNET_OK == GNUNET_TESTING_peer_kill(peer));
      return;
    }
  GNUNET_break(GNUNET_OK == GNUNET_TESTING_peer_wait(peer));
  GNUNET_ARM_disconnect(peer->ah);
  peer->ah = NULL;
  peer->cb(peer->cb_cls, peer, GNUNET_YES);
}

Here is the call graph for this function:

Here is the caller graph for this function:

service_run_main()

static void service_run_main ( void *  cls )

static

Callback to be called when SCHEDULER has been started.

Parameters

cls	the ServiceContext

Definition at line 1635 of file testing.c.

References ServiceContext::cfg, ServiceContext::peer, sc, ServiceContext::tm, and ServiceContext::tm_cls.

Referenced by GNUNET_TESTING_service_run().

{
  struct ServiceContext *sc = cls;

  sc->tm(sc->tm_cls, sc->cfg, sc->peer);
}

Here is the caller graph for this function: