Testing library

Library for writing testcases for GNUnet. More...

Collaboration diagram for Testing library:

Data Structures
struct	GNUNET_TESTING_SharedService
	Specification of a service that is to be shared among peers. More...

Macros
#define	GNUNET_TESTING_HOSTKEYFILESIZE
	Size of each hostkey in the hostkey file (in BYTES). More...
#define	GNUNET_TESTING_PREFIX   "GNUNET_TESTING_PREFIX"
	The environmental variable, if set, that dictates where testing should place generated peer configurations. More...

Typedefs
typedef void(*	GNUNET_TESTING_PeerStopCallback) (void *cls, struct GNUNET_TESTING_Peer *peer, int success)
	Callback to inform whether the peer is running or stopped. More...
typedef void(*	GNUNET_TESTING_TestMain) (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_TESTING_Peer *peer)
	Signature of the 'main' function for a (single-peer) testcase that is run using GNUNET_TESTING_peer_run(). More...

Functions
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...
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...
void	GNUNET_TESTING_system_destroy (struct GNUNET_TESTING_System *system, int remove_paths)
	Free system resources. 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...
uint16_t	GNUNET_TESTING_reserve_port (struct GNUNET_TESTING_System *system)
	Reserve a 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...
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_stop (struct GNUNET_TESTING_Peer *peer)
	Stop the peer. More...
void	GNUNET_TESTING_peer_destroy (struct GNUNET_TESTING_Peer *peer)
	Destroy 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_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...
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...
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...

Detailed Description

Library for writing testcases for GNUnet.

It can start/stop one or more peers on a system; testing is responsible for managing private keys, ports and paths; it is a low-level library that does not support higher-level functions such as P2P connection, topology management or distributed testbed maintenance (those are provided by the Testbed service)

See also

Documentation

Macro Definition Documentation

GNUNET_TESTING_HOSTKEYFILESIZE

#define GNUNET_TESTING_HOSTKEYFILESIZE

Value:

                                              sizeof(struct \
                                              GNUNET_CRYPTO_EddsaPrivateKey)

Size of each hostkey in the hostkey file (in BYTES).

Definition at line 63 of file gnunet_testing_lib.h.

GNUNET_TESTING_PREFIX

#define GNUNET_TESTING_PREFIX   "GNUNET_TESTING_PREFIX"

The environmental variable, if set, that dictates where testing should place generated peer configurations.

Definition at line 70 of file gnunet_testing_lib.h.

Typedef Documentation

GNUNET_TESTING_PeerStopCallback

typedef void(* GNUNET_TESTING_PeerStopCallback) (void *cls, struct GNUNET_TESTING_Peer *peer, int success)

Callback to inform whether the peer is running or stopped.

Parameters

cls	the closure given to GNUNET_TESTING_peer_stop_async()
peer	the respective peer whose status is being reported
success	GNUNET_YES if the peer is stopped; GNUNET_SYSERR upon any error

Definition at line 350 of file gnunet_testing_lib.h.

GNUNET_TESTING_TestMain

typedef void(* GNUNET_TESTING_TestMain) (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_TESTING_Peer *peer)

Signature of the 'main' function for a (single-peer) testcase that is run using GNUNET_TESTING_peer_run().

Parameters

cls	closure
cfg	configuration of the peer that was started
peer	identity of the peer that was created

Definition at line 394 of file gnunet_testing_lib.h.

Function Documentation

GNUNET_TESTING_system_create()

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.

There must only be one system handle per operating system. Uses a default range for allowed ports. Ports are still tested for availability.

Parameters

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. This variable will be overridden with the value of the environmental variable GNUNET_TESTING_PREFIX, if it exists.
trusted_ip	the ip address which will be set as TRUSTED HOST in all service configurations generated to allow control connections from this ip. This can either be a single ip address or a network address in CIDR notation.
hostname	the hostname of the system we are using for testing; NULL for localhost
shared_services	NULL terminated array describing services that are to be shared among peers

Returns

handle to this system, NULL on error

Definition at line 477 of file testing.c.

{
  return GNUNET_TESTING_system_create_with_portrange (testdir,
                                                      trusted_ip,
                                                      hostname,
                                                      shared_services,
                                                      LOW_PORT,
                                                      HIGH_PORT);
}

References GNUNET_TESTING_system_create_with_portrange(), HIGH_PORT, hostname, LOW_PORT, GNUNET_TESTING_System::shared_services, and GNUNET_TESTING_System::trusted_ip.

Referenced by create_hostkeys(), create_unique_cfgs(), GNUNET_TESTING_service_run(), GNUNET_TRANSPORT_TESTING_init(), handle_init(), system_create_run(), and tokenizer_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_system_create_with_portrange()

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.

There must only be one system handle per operating system. Use this function directly if multiple system objects are created for the same host (only really useful when testing — or to make the port range configurable).

Parameters

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. This variable will be overridden with the value of the environmental variable GNUNET_TESTING_PREFIX, if it exists.
trusted_ip	the ip address which will be set as TRUSTED HOST in all service configurations generated to allow control connections from this ip. This can either be a single ip address or a network address in CIDR notation.
hostname	the hostname of the system we are using for testing; NULL for localhost
shared_services	NULL terminated array describing services that are to be shared among peers
lowport	lowest port number this system is allowed to allocate (inclusive)
highport	highest port number this system is allowed to allocate (exclusive)

Returns

handle to this system, NULL on error

There must only be one system handle per operating system.

Parameters

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. This variable will be overridden with the value of the environmental variable GNUNET_TESTING_PREFIX, if it exists.
trusted_ip	the ip address which will be set as TRUSTED HOST in all service configurations generated to allow control connections from this ip. This can either be a single ip address or a network address in CIDR notation.
hostname	the hostname of the system we are using for testing; NULL for localhost
shared_services	NULL terminated array describing services that are to be shared among peers
lowport	lowest port number this system is allowed to allocate (inclusive)
highport	highest port number this system is allowed to allocate (exclusive)

Returns

handle to this system, NULL on error

Definition at line 392 of file testing.c.

{
  struct GNUNET_TESTING_System *system;
  struct GNUNET_TESTING_SharedService tss;
  struct SharedService ss;
  unsigned int cnt;
 
  GNUNET_assert (NULL != testdir);
  system = GNUNET_new (struct GNUNET_TESTING_System);
  if (NULL == (system->tmppath = getenv (GNUNET_TESTING_PREFIX)))
    system->tmppath = GNUNET_DISK_mkdtemp (testdir);
  else
    system->tmppath = GNUNET_strdup (system->tmppath);
  system->lowport = lowport;
  system->highport = highport;
  if (NULL == system->tmppath)
  {
    GNUNET_free (system);
    return NULL;
  }
  if (NULL != trusted_ip)
    system->trusted_ip = GNUNET_strdup (trusted_ip);
  if (NULL != hostname)
    system->hostname = GNUNET_strdup (hostname);
  if (GNUNET_OK != hostkeys_load (system))
  {
    GNUNET_TESTING_system_destroy (system, GNUNET_YES);
    return NULL;
  }
  if (NULL == shared_services)
    return system;
  for (cnt = 0; NULL != shared_services[cnt].service; cnt++)
  {
    tss = shared_services[cnt];
    memset (&ss, 0, sizeof (ss));
    ss.sname = GNUNET_strdup (tss.service);
    ss.cfg = GNUNET_CONFIGURATION_create ();
    GNUNET_CONFIGURATION_iterate_section_values (tss.cfg,
                                                 ss.sname,
                                                 &cfg_copy_iterator,
                                                 ss.cfg);
    GNUNET_CONFIGURATION_iterate_section_values (tss.cfg,
                                                 "TESTING",
                                                 &cfg_copy_iterator,
                                                 ss.cfg);
    GNUNET_CONFIGURATION_iterate_section_values (tss.cfg,
                                                 "PATHS",
                                                 &cfg_copy_iterator,
                                                 ss.cfg);
    ss.share = tss.share;
    GNUNET_array_append (system->shared_services,
                         system->n_shared_services,
                         ss);
  }
  return system;
}

References GNUNET_TESTING_SharedService::cfg, SharedService::cfg, cfg_copy_iterator(), getenv(), GNUNET_array_append, GNUNET_assert, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_iterate_section_values(), GNUNET_DISK_mkdtemp(), GNUNET_free, GNUNET_new, GNUNET_OK, GNUNET_strdup, GNUNET_TESTING_PREFIX, GNUNET_TESTING_system_destroy(), GNUNET_YES, GNUNET_TESTING_System::highport, hostkeys_load(), hostname, GNUNET_TESTING_System::hostname, GNUNET_TESTING_System::lowport, GNUNET_TESTING_System::n_shared_services, GNUNET_TESTING_SharedService::service, GNUNET_TESTING_SharedService::share, SharedService::share, GNUNET_TESTING_System::shared_services, SharedService::sname, GNUNET_TESTING_System::tmppath, and GNUNET_TESTING_System::trusted_ip.

Referenced by GNUNET_TESTING_system_create().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_system_destroy()

void GNUNET_TESTING_system_destroy	(	struct GNUNET_TESTING_System *	system,
		int	remove_paths
	)

Free system resources.

Parameters

system	system to be freed
remove_paths	should the 'testdir' and all subdirectories be removed (clean up on shutdown)?

Definition at line 557 of file testing.c.

{
  struct SharedService *ss;
  struct SharedServiceInstance *i;
  unsigned int ss_cnt;
  unsigned int i_cnt;
 
  if (NULL != system->hostkeys_data)
    hostkeys_unload (system);
  for (ss_cnt = 0; ss_cnt < system->n_shared_services; ss_cnt++)
  {
    ss = &system->shared_services[ss_cnt];
    for (i_cnt = 0; i_cnt < ss->n_instances; i_cnt++)
    {
      i = ss->instances[i_cnt];
      if (NULL != i->proc)
        stop_shared_service_instance (i);
      cleanup_shared_service_instance (i);
    }
    GNUNET_free (ss->instances);
    GNUNET_CONFIGURATION_destroy (ss->cfg);
    GNUNET_free (ss->sname);
  }
  GNUNET_free (system->shared_services);
  if (GNUNET_YES == remove_paths)
    GNUNET_DISK_directory_remove (system->tmppath);
  GNUNET_free (system->tmppath);
  GNUNET_free (system->trusted_ip);
  GNUNET_free (system->hostname);
  GNUNET_free (system);
}

References SharedService::cfg, cleanup_shared_service_instance(), GNUNET_CONFIGURATION_destroy(), GNUNET_DISK_directory_remove(), GNUNET_free, GNUNET_YES, GNUNET_TESTING_System::hostkeys_data, hostkeys_unload(), GNUNET_TESTING_System::hostname, SharedService::instances, SharedService::n_instances, GNUNET_TESTING_System::n_shared_services, SharedServiceInstance::proc, GNUNET_TESTING_System::shared_services, SharedService::sname, SharedServiceInstance::ss, stop_shared_service_instance(), GNUNET_TESTING_System::tmppath, and GNUNET_TESTING_System::trusted_ip.

Referenced by create_hostkeys(), create_unique_cfgs(), GNUNET_TESTING_service_run(), GNUNET_TESTING_system_create_with_portrange(), GNUNET_TRANSPORT_TESTING_done(), shutdown_task(), and system_destroy_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_hostkey_get()

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.

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

Parameters

system	the testing system handle
key_number	desired pre-created hostkey to obtain
id	set to the peer's identity (hash of the public key; if NULL, GNUNET_SYSERR is returned immediately

Returns

NULL on error (not enough keys)

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.

Parameters

system	the testing system handle
key_number	desired pre-created hostkey to obtain
id	set to the peer's identity (hash of the public key; if NULL, NULL is returned immediately

Returns

NULL on error (not enough keys)

Definition at line 732 of file testing.c.

{
  struct GNUNET_CRYPTO_EddsaPrivateKey *private_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_new (struct GNUNET_CRYPTO_EddsaPrivateKey);
  GNUNET_memcpy (private_key,
                 system->hostkeys_data
                 + (key_number * GNUNET_TESTING_HOSTKEYFILESIZE),
                 GNUNET_TESTING_HOSTKEYFILESIZE);
  GNUNET_CRYPTO_eddsa_key_get_public (private_key, &id->public_key);
  return private_key;
}

References _, GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_ERROR_TYPE_ERROR, GNUNET_memcpy, GNUNET_new, GNUNET_TESTING_HOSTKEYFILESIZE, GNUNET_TESTING_System::hostkeys_data, id, LOG, and GNUNET_TESTING_System::total_hostkeys.

Referenced by create_hostkeys(), GNUNET_TESTING_get_peer(), GNUNET_TESTING_peer_configure(), and GNUNET_TESTING_peer_get_identity().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_reserve_port()

uint16_t GNUNET_TESTING_reserve_port

(

struct GNUNET_TESTING_System *

system

)

Reserve a port for a peer.

Parameters

system

system to use for reservation tracking

Returns

0 if no free port was available

Reserve a port for a peer.

Parameters

system

system to use for reservation tracking

Returns

0 if no free port was available

Definition at line 598 of file testing.c.

{
  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 = 0;
  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 = system->reserved_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 (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, SOCK_STREAM, 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;
        socket = GNUNET_NETWORK_socket_create (ai->ai_family, 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++;
    }
  }
  return 0;
}

References ai, AI_NUMERICSERV, GNUNET_asprintf(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_NO, GNUNET_OK, GNUNET_TESTING_System::highport, LOG, GNUNET_TESTING_System::lowport, GNUNET_TESTING_System::reserved_ports, and ret.

Referenced by associate_shared_service(), and update_config().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_release_port()

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

Parameters

system	system to use for reservation tracking
port	reserved port to release

Release reservation of a TCP or UDP port for a peer (used during GNUNET_TESTING_peer_destroy).

Parameters

system	system to use for reservation tracking
port	reserved port to release

Definition at line 694 of file testing.c.

{
  uint32_t *port_buckets;
  uint16_t bucket;
  uint16_t pos;
 
  port_buckets = system->reserved_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);
}

References GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, LOG, port, and GNUNET_TESTING_System::reserved_ports.

Referenced by GNUNET_TESTING_peer_destroy().

Here is the caller graph for this function:

GNUNET_TESTING_configuration_create()

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.

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

Returns

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

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

Returns

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

Definition at line 1167 of file testing.c.

{
  return GNUNET_TESTING_configuration_create_ (system, cfg, NULL, NULL);
}

References cfg, GNUNET_TESTING_configuration_create_(), and UpdateContext::system.

Referenced by create_unique_cfgs(), GNUNET_TRANSPORT_TESTING_start_peer(), start_peer_run(), and tokenizer_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_peer_configure()

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.

GNUnet must be installed on the local system and available in the PATH.

Parameters

system	system to use to coordinate resource usage
cfg	configuration to use; will be UPDATED (to reflect needed changes in port numbers and paths)
key_number	number of the hostkey to use for the peer
id	identifier for the daemon, will be set, can be NULL
emsg	set to freshly allocated error message (set to NULL on success), can be NULL

Returns

handle to the peer, NULL on error

Definition at line 1188 of file testing.c.

{
  struct GNUNET_TESTING_Peer *peer;
  struct GNUNET_DISK_FileHandle *fd;
  char *hostkey_filename;
  char *config_filename;
  char *libexec_binary;
  char *emsg_;
  struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
  uint16_t *ports;
  struct SharedService *ss;
  struct SharedServiceInstance **ss_instances;
  unsigned int cnt;
  unsigned int nports;
 
  ports = NULL;
  nports = 0;
  ss_instances = NULL;
  if (NULL != emsg)
    *emsg = 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);
    goto err_ret;
  }
  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);
    goto err_ret;
  }
  if (NULL != pk)
    GNUNET_free (pk);
  if (GNUNET_NO == GNUNET_CONFIGURATION_have_value (cfg, "PEER", "PRIVATE_KEY"))
  {
    GNUNET_asprintf (
      &emsg_,
      _ ("PRIVATE_KEY option in PEER section missing in configuration\n"));
    goto err_ret;
  }
  /* Remove sections for shared services */
  for (cnt = 0; cnt < system->n_shared_services; cnt++)
  {
    ss = &system->shared_services[cnt];
    GNUNET_CONFIGURATION_remove_section (cfg, ss->sname);
  }
  if (GNUNET_OK !=
      GNUNET_TESTING_configuration_create_ (system, cfg, &ports, &nports))
  {
    GNUNET_asprintf (&emsg_,
                     _ ("Failed to create configuration for peer "
                        "(not enough free ports?)\n"));
    goto err_ret;
  }
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                          "PEER",
                                                          "PRIVATE_KEY",
                                                          &hostkey_filename));
  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_asprintf (&emsg_,
                     _ ("Cannot open hostkey file `%s': %s\n"),
                     hostkey_filename,
                     strerror (errno));
    GNUNET_free (hostkey_filename);
    goto err_ret;
  }
  GNUNET_free (hostkey_filename);
  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_DISK_file_close (fd);
    goto err_ret;
  }
  GNUNET_DISK_file_close (fd);
  ss_instances = GNUNET_new_array (system->n_shared_services,
                                   struct SharedServiceInstance*);
  for (cnt = 0; cnt < system->n_shared_services; cnt++)
  {
    ss = &system->shared_services[cnt];
    ss_instances[cnt] = associate_shared_service (system, ss, cfg);
    if (NULL == ss_instances[cnt])
    {
      emsg_ = GNUNET_strdup ("FIXME");
      goto err_ret;
    }
  }
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONFIGURATION_get_value_filename (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_free (config_filename);
    goto err_ret;
  }
  peer = GNUNET_new (struct GNUNET_TESTING_Peer);
  peer->ss_instances = ss_instances;
  peer->cfgfile = config_filename; /* Free in peer_destroy */
  peer->cfg = GNUNET_CONFIGURATION_dup (cfg);
  libexec_binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm");
  if (GNUNET_SYSERR ==
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             "arm",
                                             "PREFIX",
                                             &peer->main_binary))
  {
    /* No prefix */
    GNUNET_asprintf (&peer->main_binary, "%s", libexec_binary);
    peer->args = GNUNET_strdup ("");
  }
  else
  {
    peer->args = GNUNET_strdup (libexec_binary);
  }
  peer->system = system;
  peer->key_number = key_number;
  GNUNET_free (libexec_binary);
  peer->ports = ports; /* Free in peer_destroy */
  peer->nports = nports;
  return peer;
 
err_ret:
  GNUNET_free (ss_instances);
  GNUNET_free (ports);
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s", emsg_);
  if (NULL != emsg)
    *emsg = emsg_;
  else
    GNUNET_free (emsg_);
  return NULL;
}

References _, associate_shared_service(), cfg, GNUNET_DISK_FileHandle::fd, GNUNET_asprintf(), GNUNET_assert, GNUNET_CONFIGURATION_dup(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_have_value(), GNUNET_CONFIGURATION_remove_section(), GNUNET_CONFIGURATION_write(), GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_write(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_new_array, GNUNET_NO, GNUNET_OK, GNUNET_OS_get_libexec_binary_path(), GNUNET_strdup, GNUNET_SYSERR, GNUNET_TESTING_configuration_create_(), GNUNET_TESTING_hostkey_get(), GNUNET_TESTING_HOSTKEYFILESIZE, GNUNET_TESTING_System::hostkeys_data, GNUNET_TESTING_System::n_shared_services, peer, pk, GNUNET_TESTING_System::shared_services, SharedService::sname, SharedServiceInstance::ss, and GNUNET_TESTING_System::total_hostkeys.

Referenced by GNUNET_TESTING_service_run(), GNUNET_TRANSPORT_TESTING_start_peer(), handle_peer_create(), start_peer_run(), and update_peer_config().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_peer_get_identity()

void GNUNET_TESTING_peer_get_identity	(	struct GNUNET_TESTING_Peer *	peer,
		struct GNUNET_PeerIdentity *	id
	)

Obtain the peer identity from a peer handle.

Parameters

peer	peer handle for which we want the peer's identity
id	identifier for the daemon, will be set

Definition at line 1359 of file testing.c.

{
  if (NULL != peer->id)
  {
    GNUNET_memcpy (id, peer->id, sizeof(struct GNUNET_PeerIdentity));
    return;
  }
  peer->id = GNUNET_new (struct GNUNET_PeerIdentity);
  GNUNET_free_nz (
    GNUNET_TESTING_hostkey_get (peer->system, peer->key_number, peer->id));
  GNUNET_memcpy (id, peer->id, sizeof(struct GNUNET_PeerIdentity));
}

References GNUNET_free_nz, GNUNET_memcpy, GNUNET_new, GNUNET_TESTING_hostkey_get(), and peer.

Referenced by GNUNET_TRANSPORT_TESTING_start_peer(), handle_overlay_connect(), handle_peer_get_config(), handle_remote_overlay_connect(), and start_peer_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_peer_start()

int GNUNET_TESTING_peer_start

(

struct GNUNET_TESTING_Peer *

peer

)

Start the peer.

Parameters

peer	peer to start

Returns

GNUNET_OK on success, GNUNET_SYSERR on error (i.e. peer already running)

Definition at line 1381 of file testing.c.

{
  struct SharedServiceInstance *i;
  unsigned int cnt;
 
  if (NULL != peer->main_process)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  GNUNET_assert (NULL != peer->cfgfile);
  for (cnt = 0; cnt < peer->system->n_shared_services; cnt++)
  {
    i = peer->ss_instances[cnt];
    if ((0 == i->n_refs) &&
        (GNUNET_SYSERR == start_shared_service_instance (i)))
      return GNUNET_SYSERR;
    i->n_refs++;
  }
  peer->main_binary =
    GNUNET_CONFIGURATION_expand_dollar (peer->cfg, peer->main_binary);
  peer->main_process =
    GNUNET_OS_start_process_s (GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
                               NULL,
                               peer->main_binary,
                               peer->args,
                               "-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;
}

References _, GNUNET_assert, GNUNET_break, GNUNET_CONFIGURATION_expand_dollar(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, GNUNET_OS_start_process_s(), GNUNET_SYSERR, SharedServiceInstance::n_refs, peer, and start_shared_service_instance().

Referenced by GNUNET_TESTING_service_run(), GNUNET_TRANSPORT_TESTING_restart_peer(), GNUNET_TRANSPORT_TESTING_start_peer(), start_peer(), start_peer_run(), and stdin_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_peer_stop()

int GNUNET_TESTING_peer_stop

(

struct GNUNET_TESTING_Peer *

peer

)

Stop the peer.

This call is blocking as it kills the peer's main ARM process by sending a SIGTERM and waits on it. For asynchronous shutdown of peer, see GNUNET_TESTING_peer_stop_async().

Parameters

peer	peer to stop

Returns

GNUNET_OK on success, GNUNET_SYSERR on error (i.e. peer not running)

Parameters

peer	peer to stop

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1485 of file testing.c.

{
  if (GNUNET_SYSERR == GNUNET_TESTING_peer_kill (peer))
    return GNUNET_SYSERR;
  if (GNUNET_SYSERR == GNUNET_TESTING_peer_wait (peer))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

References GNUNET_OK, GNUNET_SYSERR, GNUNET_TESTING_peer_kill(), GNUNET_TESTING_peer_wait(), and peer.

Referenced by GNUNET_TESTING_peer_destroy(), GNUNET_TESTING_service_run(), GNUNET_TRANSPORT_TESTING_restart_peer(), GNUNET_TRANSPORT_TESTING_stop_peer(), GST_destroy_peer(), stdin_cb(), and stop_peer_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_peer_destroy()

void GNUNET_TESTING_peer_destroy

(

struct GNUNET_TESTING_Peer *

peer

)

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

Parameters

peer	peer to destroy

Definition at line 1566 of file testing.c.

{
  unsigned int cnt;
 
  if (NULL != peer->main_process)
    GNUNET_TESTING_peer_stop (peer);
  if (NULL != peer->ah)
    GNUNET_ARM_disconnect (peer->ah);
  GNUNET_free (peer->cfgfile);
  if (NULL != peer->cfg)
    GNUNET_CONFIGURATION_destroy (peer->cfg);
  GNUNET_free (peer->main_binary);
  GNUNET_free (peer->args);
  GNUNET_free (peer->id);
  GNUNET_free (peer->ss_instances);
  if (NULL != peer->ports)
  {
    for (cnt = 0; cnt < peer->nports; cnt++)
      GNUNET_TESTING_release_port (peer->system, peer->ports[cnt]);
    GNUNET_free (peer->ports);
  }
  GNUNET_free (peer);
}

References GNUNET_ARM_disconnect(), GNUNET_CONFIGURATION_destroy(), GNUNET_free, GNUNET_TESTING_peer_stop(), GNUNET_TESTING_release_port(), and peer.

Referenced by GNUNET_TESTING_service_run(), GNUNET_TRANSPORT_TESTING_stop_peer(), GST_destroy_peer(), GST_destroy_peers(), stop_peer_run(), and update_peer_config().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_peer_kill()

int GNUNET_TESTING_peer_kill

(

struct GNUNET_TESTING_Peer *

peer

)

Sends SIGTERM to the peer's main process.

Parameters

peer	the handle to the peer

Returns

GNUNET_OK if successful; GNUNET_SYSERR if the main process is NULL or upon any error while sending SIGTERM

Definition at line 1430 of file testing.c.

{
  struct SharedServiceInstance *i;
  unsigned int cnt;
 
  if (NULL == peer->main_process)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (0 != GNUNET_OS_process_kill (peer->main_process, GNUNET_TERM_SIG))
    return GNUNET_SYSERR;
  for (cnt = 0; cnt < peer->system->n_shared_services; cnt++)
  {
    i = peer->ss_instances[cnt];
    GNUNET_assert (0 != i->n_refs);
    i->n_refs--;
    if (0 == i->n_refs)
      stop_shared_service_instance (i);
  }
  return GNUNET_OK;
}

References GNUNET_assert, GNUNET_break, GNUNET_OK, GNUNET_OS_process_kill(), GNUNET_SYSERR, GNUNET_TERM_SIG, SharedServiceInstance::n_refs, peer, and stop_shared_service_instance().

Referenced by disconn_status(), GNUNET_TESTING_peer_stop(), GST_destroy_peers(), and stop_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_peer_wait()

int GNUNET_TESTING_peer_wait

(

struct GNUNET_TESTING_Peer *

peer

)

Waits for a peer to terminate.

The peer's main process will also be destroyed.

Parameters

peer	the handle to the peer

Returns

GNUNET_OK if successful; GNUNET_SYSERR if the main process is NULL or upon any error while waiting

Definition at line 1462 of file testing.c.

{
  int ret;
 
  if (NULL == peer->main_process)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  ret = GNUNET_OS_process_wait (peer->main_process);
  GNUNET_OS_process_destroy (peer->main_process);
  peer->main_process = NULL;
  return ret;
}

References GNUNET_break, GNUNET_OS_process_destroy(), GNUNET_OS_process_wait(), GNUNET_SYSERR, peer, and ret.

Referenced by disconn_status(), GNUNET_TESTING_peer_stop(), GST_destroy_peers(), and handle_peer_stop().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_peer_stop_async()

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.

Peer's shutdown is signaled through the GNUNET_TESTING_PeerStopCallback().

Parameters

peer	the peer to stop
cb	the callback to signal peer shutdown
cb_cls	closure for the cb

Returns

GNUNET_OK upon successfully giving the request to the ARM API (this does not mean that the peer is successfully stopped); GNUNET_SYSERR upon any error.

Definition at line 1525 of file testing.c.

{
  if (NULL == peer->main_process)
    return GNUNET_SYSERR;
  peer->ah = GNUNET_ARM_connect (peer->cfg, &disconn_status, peer);
  if (NULL == peer->ah)
    return GNUNET_SYSERR;
  peer->cb = cb;
  peer->cb_cls = cb_cls;
  return GNUNET_OK;
}

References GNUNET_TESTING_Peer::cb, GNUNET_TESTING_Peer::cb_cls, disconn_status(), GNUNET_ARM_connect(), GNUNET_OK, GNUNET_SYSERR, and peer.

Referenced by handle_peer_reconfigure().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_peer_stop_async_cancel()

void GNUNET_TESTING_peer_stop_async_cancel

(

struct GNUNET_TESTING_Peer *

peer

)

Cancel a previous asynchronous peer stop request.

GNUNET_TESTING_peer_stop_async() should have been called before on the given peer. It is an error to call this function if the peer stop callback was already called

Parameters

peer	the peer on which GNUNET_TESTING_peer_stop_async() was called before.

Definition at line 1550 of file testing.c.

{
  GNUNET_assert (NULL != peer->ah);
  GNUNET_ARM_disconnect (peer->ah);
  peer->ah = NULL;
}

References GNUNET_ARM_disconnect(), GNUNET_assert, and peer.

Referenced by cleanup_prc().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_peer_run()

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.

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

Parameters

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
cfgfilename	name of the configuration file to use; use NULL to only run with defaults
tm	main function of the testcase
tm_cls	closure for tm

Returns

0 on success, 1 on error

Definition at line 1592 of file testing.c.

{
  return GNUNET_TESTING_service_run (testdir, "arm", cfgfilename, tm, tm_cls);
}

References GNUNET_TESTING_service_run().

Referenced by pre_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_service_run()

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.

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

This function is useful if the testcase is for a single service and if that service doesn't itself depend on other services.

Parameters

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
service_name	name of the service to run
cfgfilename	name of the configuration file to use; use NULL to only run with defaults
tm	main function of the testcase
tm_cls	closure for tm

Returns

0 on success, 1 on error

Definition at line 1643 of file testing.c.

{
  struct ServiceContext sc;
  struct GNUNET_TESTING_System *system;
  struct GNUNET_TESTING_Peer *peer;
  struct GNUNET_CONFIGURATION_Handle *cfg;
  char *binary;
  char *libexec_binary;
 
  GNUNET_log_setup (testdir, "WARNING", NULL);
  system = GNUNET_TESTING_system_create (testdir, "127.0.0.1", NULL, 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_free (peer->args);
  GNUNET_asprintf (&binary, "gnunet-service-%s", service_name);
  libexec_binary = GNUNET_OS_get_libexec_binary_path (binary);
  if (GNUNET_SYSERR ==
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             service_name,
                                             "PREFIX",
                                             &peer->main_binary))
  {
    /* No prefix */
    GNUNET_asprintf (&peer->main_binary, "%s", libexec_binary);
    peer->args = GNUNET_strdup ("");
  }
  else
    peer->args = GNUNET_strdup (libexec_binary);
 
  GNUNET_free (libexec_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;
}

References _, cfg, GNUNET_asprintf(), GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_load(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_setup(), GNUNET_OK, GNUNET_OS_get_libexec_binary_path(), GNUNET_SCHEDULER_run(), GNUNET_strdup, GNUNET_SYSERR, GNUNET_TESTING_peer_configure(), GNUNET_TESTING_peer_destroy(), GNUNET_TESTING_peer_start(), GNUNET_TESTING_peer_stop(), GNUNET_TESTING_system_create(), GNUNET_TESTING_system_destroy(), GNUNET_YES, hostkeys_unload(), LOG, peer, sc, service_name, and service_run_main().

Referenced by GNUNET_TESTING_peer_run(), and run_no_scheduler().

Here is the call graph for this function:

Here is the caller graph for this function: