gnunet_testbed_lib.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	GNUNET_TESTBED_PREFIX   "GNUNET_TESTBED_PREFIX"

Functions
struct GNUNET_TESTBED_System *	GNUNET_TESTBED_system_create_with_portrange (const char *testdir, const char *trusted_ip, const char *hostname, uint16_t lowport, uint16_t highport)
	Create a system handle. More...
struct GNUNET_TESTBED_System *	GNUNET_TESTBED_system_create (const char *testdir, const char *trusted_ip, const char *hostname)
	Create a system handle. More...
void	GNUNET_TESTBED_system_destroy (struct GNUNET_TESTBED_System *system, bool remove_paths)
	Free system resources. More...
uint16_t	GNUNET_TESTBED_reserve_port (struct GNUNET_TESTBED_System *system)
	Reserve a TCP or UDP port for a peer. More...
void	GNUNET_TESTBED_release_port (struct GNUNET_TESTBED_System *system, uint16_t port)
	Release reservation of a TCP or UDP port for a peer (used during #GNUNET_TESTBED_peer_destroy()). More...
enum GNUNET_GenericReturnValue	GNUNET_TESTBED_configuration_create (struct GNUNET_TESTBED_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...

Macro Definition Documentation

GNUNET_TESTBED_PREFIX

#define GNUNET_TESTBED_PREFIX   "GNUNET_TESTBED_PREFIX"

Definition at line 9 of file gnunet_testbed_lib.h.

Function Documentation

GNUNET_TESTBED_system_create_with_portrange()

struct GNUNET_TESTBED_System * GNUNET_TESTBED_system_create_with_portrange	(	const char *	testdir,
		const char *	trusted_ip,
		const char *	hostname,
		uint16_t	lowport,
		uint16_t	highport
	)

Create a system handle.

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_TESTBED_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
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 105 of file testbed.c.

{
  struct GNUNET_TESTBED_System *system;
 
  GNUNET_assert (NULL != testdir);
  system = GNUNET_new (struct GNUNET_TESTBED_System);
  if (NULL == (system->tmppath = getenv (GNUNET_TESTBED_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);
  return system;
}

References getenv(), GNUNET_assert, GNUNET_DISK_mkdtemp(), GNUNET_free, GNUNET_new, GNUNET_strdup, GNUNET_TESTBED_PREFIX, GNUNET_TESTBED_System::highport, GNUNET_TESTBED_System::hostname, GNUNET_TESTBED_System::lowport, GNUNET_TESTBED_System::tmppath, and GNUNET_TESTBED_System::trusted_ip.

Referenced by GNUNET_TESTBED_system_create().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_system_create()

struct GNUNET_TESTBED_System * GNUNET_TESTBED_system_create	(	const char *	testdir,
		const char *	trusted_ip,
		const char *	hostname
	)

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_TESTBED_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 136 of file testbed.c.

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

References GNUNET_TESTBED_system_create_with_portrange(), HIGH_PORT, GNUNET_TESTBED_System::hostname, LOW_PORT, and GNUNET_TESTBED_System::trusted_ip.

Referenced by create_unique_cfgs(), and system_create_run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_system_destroy()

void GNUNET_TESTBED_system_destroy	(	struct GNUNET_TESTBED_System *	system,
		bool	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 150 of file testbed.c.

{
  if (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 GNUNET_DISK_directory_remove(), GNUNET_free, GNUNET_TESTBED_System::hostname, GNUNET_TESTBED_System::tmppath, and GNUNET_TESTBED_System::trusted_ip.

Referenced by create_unique_cfgs(), and system_create_cleanup().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_reserve_port()

uint16_t GNUNET_TESTBED_reserve_port

(

struct GNUNET_TESTBED_System *

system

)

Reserve a TCP or UDP port for a peer.

Parameters

system

system to use for reservation tracking

Returns

0 if no free port was available

Definition at line 163 of file testbed.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_TESTBED_System::highport, LOG, GNUNET_TESTBED_System::lowport, GNUNET_TESTBED_System::reserved_ports, and ret.

Referenced by update_config().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTBED_release_port()

void GNUNET_TESTBED_release_port	(	struct GNUNET_TESTBED_System *	system,
		uint16_t	port
	)

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

Parameters

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

Definition at line 252 of file testbed.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_TESTBED_System::reserved_ports.

GNUNET_TESTBED_configuration_create()

enum GNUNET_GenericReturnValue GNUNET_TESTBED_configuration_create	(	struct GNUNET_TESTBED_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.

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_TESTBED_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 532 of file testbed.c.

{
  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 (uc.ports);
  return uc.status;
}

References cfg, GNUNET_asprintf(), GNUNET_CONFIGURATION_iterate(), GNUNET_CONFIGURATION_iterate_sections(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_free, GNUNET_OK, UpdateContext::nports, GNUNET_TESTBED_System::path_counter, UpdateContext::ports, UpdateContext::system, GNUNET_TESTBED_System::tmppath, uc, update_config(), and update_config_sections().

Referenced by create_unique_cfgs(), and start_peer_run().

Here is the call graph for this function:

Here is the caller graph for this function: