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 "gnunet_testing_ng_lib.h"
#include "gnunet_testing_plugin.h"
#include "gnunet_testing_barrier.h"
#include "gnunet_testing_netjail_lib.h"
#include "testing_cmds.h"

Include dependency graph for testing.c:

Data Structures
struct	SharedServiceInstance

struct	SharedService

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 iterator for updating. More...

struct	ServiceContext
	Structure for holding service data. More...

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

#define	CONNECT_ADDRESS_TEMPLATE "%s-192.168.15.%u"

#define	ROUTER_CONNECT_ADDRESS_TEMPLATE "%s-92.68.150.%u"

#define	KNOWN_CONNECT_ADDRESS_TEMPLATE "%s-92.68.151.%u"

#define	PREFIX_TCP "tcp"

#define	PREFIX_UDP "udp"

#define	PREFIX_TCP_NATTED "tcp_natted"

#define	PREFIX_UDP_NATTED "udp_natted"

#define	LOW_PORT 12000
	Lowest port used for GNUnet testing. More...

#define	HIGH_PORT 56000
	Highest port used for GNUnet testing. More...

Functions
static enum GNUNET_GenericReturnValue	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 enum GNUNET_GenericReturnValue	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...

static unsigned int	get_first_value (const char *line)
	Every line in the topology configuration starts with a string indicating which kind of information will be configured with this line. More...

static char *	get_key (const char *line)
	Every line in the topology configuration starts with a string indicating which kind of information will be configured with this line. More...

static char *	get_first_string_value (const char *line)
	Every line in the topology configuration starts with a string indicating which kind of information will be configured with this line. More...

static unsigned int	get_second_value (const char *line)
	Every line in the topology configuration starts with a string indicating which kind of information will be configured with this line. More...

static char *	get_value (const char key, const char line)
	Every line in the topology configuration starts with a string indicating which kind of information will be configured with this line. More...

static struct GNUNET_TESTING_NodeConnection *	get_connect_value (const char line, struct GNUNET_TESTING_NetjailNode node)
	Every line in the topology configuration starts with a string indicating which kind of information will be configured with this line. More...

static void	node_connections (const char line, struct GNUNET_TESTING_NetjailNode node)
	Every line in the topology configuration starts with a string indicating which kind of information will be configured with this line. More...

static int	log_nodes (void cls, const struct GNUNET_ShortHashCode id, void *value)
	A helper function to log information about individual nodes. More...

static int	log_namespaces (void cls, const struct GNUNET_ShortHashCode id, void *value)
	Helper function to log information about namespaces. More...

static int	log_topo (const struct GNUNET_TESTING_NetjailTopology *topology)
	Helper function to log the configuration in case of a problem with configuration. More...

static void	get_node_info (unsigned int num, const struct GNUNET_TESTING_NetjailTopology topology, struct GNUNET_TESTING_NetjailNode node_ex, struct GNUNET_TESTING_NetjailNamespace namespace_ex, struct GNUNET_TESTING_NodeConnection *node_connections_ex)
	This function extracts information about a specific node from the topology. More...

struct GNUNET_TESTING_NetjailNode *	GNUNET_TESTING_get_node (unsigned int num, struct GNUNET_TESTING_NetjailTopology *topology)
	Get a node from the topology. More...

struct GNUNET_TESTING_NodeConnection *	GNUNET_TESTING_get_connections (unsigned int num, const struct GNUNET_TESTING_NetjailTopology *topology)
	Get the connections to other nodes for a specific node. More...

struct GNUNET_PeerIdentity *	GNUNET_TESTING_get_peer (unsigned int num, const struct GNUNET_TESTING_System *tl_system)
	Retrieve the peer identity from the test system with the unique node id. More...

int	free_nodes_cb (void cls, const struct GNUNET_ShortHashCode key, void *value)

int	free_namespaces_cb (void cls, const struct GNUNET_ShortHashCode key, void *value)

void	GNUNET_TESTING_free_topology (struct GNUNET_TESTING_NetjailTopology *topology)
	Deallocate memory of the struct GNUNET_TESTING_NetjailTopology. More...

unsigned int	GNUNET_TESTING_calculate_num (struct GNUNET_TESTING_NodeConnection node_connection, struct GNUNET_TESTING_NetjailTopology topology)
	Calculate the unique id identifying a node from a given connection. More...

char *	GNUNET_TESTING_get_address (struct GNUNET_TESTING_NodeConnection connection, const char prefix)
	Get the address for a specific communicator from a connection. More...

unsigned int	GNUNET_TESTING_get_additional_connects (unsigned int num, struct GNUNET_TESTING_NetjailTopology *topology)
	Get the number of unintentional additional connections the node waits for. More...

static void	parse_ac (struct GNUNET_TESTING_NetjailNode p_node, const char token)

struct GNUNET_TESTING_NetjailTopology *	GNUNET_TESTING_get_topo_from_string (const char *input)
	Parse the topology data. More...

struct GNUNET_TESTING_NetjailTopology *	GNUNET_TESTING_get_topo_from_file (const char *filename)
	Getting the topology from file. 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 42 of file testing.c.

◆ CONNECT_ADDRESS_TEMPLATE

#define CONNECT_ADDRESS_TEMPLATE "%s-192.168.15.%u"

Definition at line 44 of file testing.c.

◆ ROUTER_CONNECT_ADDRESS_TEMPLATE

#define ROUTER_CONNECT_ADDRESS_TEMPLATE "%s-92.68.150.%u"

Definition at line 46 of file testing.c.

◆ KNOWN_CONNECT_ADDRESS_TEMPLATE

#define KNOWN_CONNECT_ADDRESS_TEMPLATE "%s-92.68.151.%u"

Definition at line 48 of file testing.c.

◆ PREFIX_TCP

#define PREFIX_TCP "tcp"

Definition at line 62 of file testing.c.

◆ PREFIX_UDP

#define PREFIX_UDP "udp"

Definition at line 64 of file testing.c.

◆ PREFIX_TCP_NATTED

#define PREFIX_TCP_NATTED "tcp_natted"

Definition at line 66 of file testing.c.

◆ PREFIX_UDP_NATTED

#define PREFIX_UDP_NATTED "udp_natted"

Definition at line 68 of file testing.c.

◆ 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 76 of file testing.c.

◆ 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 83 of file testing.c.

Function Documentation

◆ hostkeys_load()

static enum GNUNET_GenericReturnValue 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 276 of file testing.c.

{
  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;
}

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

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 339 of file testing.c.

{
  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;
}

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

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 359 of file testing.c.

{
  struct GNUNET_CONFIGURATION_Handle *cfg2 = cls;
 
  GNUNET_CONFIGURATION_set_value_string (cfg2, section, option, value);
}

References GNUNET_CONFIGURATION_set_value_string(), and value.

Referenced by associate_shared_service(), and GNUNET_TESTING_system_create_with_portrange().

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 493 of file testing.c.

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

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

Referenced by associate_shared_service(), and GNUNET_TESTING_system_destroy().

Here is the caller graph for this function:

◆ start_shared_service_instance()

static enum GNUNET_GenericReturnValue start_shared_service_instance ( struct SharedServiceInstance * i )

static

Definition at line 509 of file testing.c.

{
  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 (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;
}

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, SharedServiceInstance::proc, SharedService::sname, and SharedServiceInstance::ss.

Referenced by GNUNET_TESTING_peer_start().

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 536 of file testing.c.

{
  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;
}

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

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 808 of file testing.c.

{
  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);
}

References GNUNET_array_append, GNUNET_asprintf(), GNUNET_break, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_free, GNUNET_OK, GNUNET_snprintf(), GNUNET_SYSERR, GNUNET_TESTING_reserve_port(), GNUNET_YES, PATH_MAX, uc, and value.

Referenced by GNUNET_TESTING_configuration_create_().

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 905 of file testing.c.

{
  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 (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);
}

References GNUNET_asprintf(), GNUNET_assert, GNUNET_break, GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_have_value(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_strdup, GNUNET_YES, key, and uc.

Referenced by GNUNET_TESTING_configuration_create_().

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 1011 of file testing.c.

{
  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;
}

References cfg, 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().

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 1104 of file testing.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_TESTING_System::path_counter, UpdateContext::ports, UpdateContext::system, GNUNET_TESTING_System::tmppath, uc, update_config(), and update_config_sections().

Referenced by GNUNET_TESTING_configuration_create(), and GNUNET_TESTING_peer_configure().

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 1503 of file testing.c.

{
  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);
}

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(), and GNUNET_YES.

Referenced by GNUNET_TESTING_peer_stop_async().

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 1634 of file testing.c.

{
  struct ServiceContext *sc = cls;
 
  sc->tm (sc->tm_cls, sc->cfg, sc->peer);
}

References sc.

Referenced by GNUNET_TESTING_service_run().

Here is the caller graph for this function:

◆ get_first_value()

static unsigned int get_first_value ( const char * line )

static

Every line in the topology configuration starts with a string indicating which kind of information will be configured with this line.

Configuration values following this string are seperated by special sequences of characters. An integer value seperated by ':' is returned by this function.

Parameters

line	The line of configuration.

Returns: An integer value.

Definition at line 1734 of file testing.c.

{
  char *copy;
  size_t slen;
  char *token;
  unsigned int ret;
  char *rest = NULL;
 
  slen = strlen (line) + 1;
  copy = GNUNET_malloc (slen);
  memcpy (copy, line, slen);
  token = strtok_r (copy, ":", &rest);
  token = strtok_r (NULL, ":", &rest);
  GNUNET_assert (1 == sscanf (token, "%u", &ret));
  GNUNET_free (copy);
  return ret;
}

References GNUNET_assert, GNUNET_free, GNUNET_malloc, line, and ret.

Referenced by GNUNET_TESTING_get_topo_from_string().

Here is the caller graph for this function:

◆ get_key()

static char * get_key ( const char * line )

static

Every line in the topology configuration starts with a string indicating which kind of information will be configured with this line.

This string is returned by this function.

Parameters

line	The line of configuration.

Returns: The leading string of this configuration line.

Definition at line 1761 of file testing.c.

{
  char *copy;
  size_t slen;
  size_t tlen;
  char *token;
  char *ret;
  char *rest = NULL;
 
  slen = strlen (line) + 1;
  copy = GNUNET_malloc (slen);
  memcpy (copy, line, slen);
  token = strtok_r (copy, ":", &rest);
  tlen = strlen (token) + 1;
  ret = GNUNET_malloc (tlen);
  memcpy (ret, token, tlen);
  GNUNET_free (copy);
  return ret;
}

References GNUNET_free, GNUNET_malloc, line, and ret.

Referenced by GNUNET_TESTING_get_topo_from_string().

Here is the caller graph for this function:

◆ get_first_string_value()

static char * get_first_string_value ( const char * line )

static

Every line in the topology configuration starts with a string indicating which kind of information will be configured with this line.

Configuration values following this string are seperated by special sequences of characters. A string value seperated by ':' is returned by this function.

Parameters

line	The line of configuration.

Returns: A string value.

Definition at line 1792 of file testing.c.

{
  char *copy;
  size_t slen, slen_token;
  char *token;
  char *ret;
  char *rest = NULL;
 
  slen = strlen (line) + 1;
  copy = GNUNET_malloc (slen);
  memcpy (copy, line, slen);
  token = strtok_r (copy, ":", &rest);
  token = strtok_r (NULL, ":", &rest);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "first token %s\n",
       token);
  slen_token = strlen (token);
  ret = GNUNET_malloc (slen_token + 1);
  memcpy (ret, token, slen_token + 1);
  GNUNET_free (copy);
  return ret;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_malloc, line, LOG, and ret.

Referenced by GNUNET_TESTING_get_topo_from_string().

Here is the caller graph for this function:

◆ get_second_value()

static unsigned int get_second_value ( const char * line )

static

Every line in the topology configuration starts with a string indicating which kind of information will be configured with this line.

Configuration values following this string are seperated by special sequences of characters. A second integer value seperated by ':' from a first value is returned by this function.

Parameters

line	The line of configuration.

Returns: An integer value.

Definition at line 1826 of file testing.c.

{
  char *copy;
  char *token;
  unsigned int ret;
  char *rest = NULL;
 
  copy = GNUNET_strdup (line);
  token = strtok_r (copy, ":", &rest);
  token = strtok_r (NULL, ":", &rest);
  token = strtok_r (NULL, ":", &rest);
  LOG (GNUNET_ERROR_TYPE_ERROR,
       "Format error in configuration line: %s\n",
       line);
  GNUNET_assert (1 == sscanf (token, "%u", &ret));
  GNUNET_free (copy);
  return ret;
}

References GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_strdup, line, LOG, and ret.

Referenced by GNUNET_TESTING_get_topo_from_string().

Here is the caller graph for this function:

◆ get_value()

static char * get_value	(	const char *	key,
		const char *	line
	)

static

Every line in the topology configuration starts with a string indicating which kind of information will be configured with this line.

Configuration values following this string are seperated by special sequences of characters. A value might be a key value pair. This function returns the value for a specific key in a configuration line.

Parameters

key	The key of the key value pair.

Returns: The value of the key value pair.

Definition at line 1857 of file testing.c.

{
  char copy[strlen (line) + 1];
  size_t slen;
  char *token;
  char *token2;
  char *temp;
  char *rest = NULL;
 
  slen = strlen (line) + 1;
  memcpy (copy, line, slen);
  temp = strstr (copy, key);
  if (NULL == temp)
    return NULL;
  token = strtok_r (temp, ":", &rest);
  if (NULL == token)
    return NULL;
  token = strtok_r (NULL, ":", &rest);
  if (NULL == token)
    return NULL;
  token2 = strtok_r (token, "}", &rest);
  if (NULL == token2)
    return NULL;
  return GNUNET_strdup (token2);
}

References GNUNET_strdup, key, and line.

Referenced by GNUNET_TESTING_get_topo_from_string(), and parse_ac().

Here is the caller graph for this function:

◆ get_connect_value()

static struct GNUNET_TESTING_NodeConnection * get_connect_value	(	const char *	line,
		struct GNUNET_TESTING_NetjailNode *	node
	)

static

Every line in the topology configuration starts with a string indicating which kind of information will be configured with this line.

Configuration values following this string are seperated by special sequences of characters. A value might be a key value pair. A special key is the 'connect' key which can appear more than once. The value is the information about a connection via some protocol to some other node. This function returns the struct GNUNET_TESTING_NodeConnection which holds the information of the connect value.

Parameters

value The value of the connect key value pair.

Returns: The struct GNUNET_TESTING_NodeConnection.

Definition at line 1897 of file testing.c.

{
  struct GNUNET_TESTING_NodeConnection *node_connection;
  char *copy;
  char *token;
  char *token2;
  unsigned int node_n;
  unsigned int namespace_n;
  char *rest = NULL;
  char *rest2 = NULL;
  struct GNUNET_TESTING_AddressPrefix *prefix;
  unsigned int sscanf_ret;
 
  node_connection = GNUNET_new (struct GNUNET_TESTING_NodeConnection);
  node_connection->node = node;
 
  copy = GNUNET_strdup (line);
  token = strtok_r (copy, ":", &rest);
  if (0 == strcmp ("{K", token))
  {
    node_connection->node_type = GNUNET_TESTING_GLOBAL_NODE;
    token = strtok_r (NULL, ":", &rest);
    GNUNET_assert (1 == sscanf (token, "%u", &node_n));
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "node_n %u\n",
         node_n);
    node_connection->node_n = node_n;
    node_connection->namespace_n = 0;
  }
  else if (0 == strcmp ("{P", token))
  {
    node_connection->node_type = GNUNET_TESTING_SUBNET_NODE;
    token = strtok_r (NULL, ":", &rest);
    errno = 0;
    sscanf_ret = sscanf (token, "%u", &namespace_n);
    if (errno != 0)
    {
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
    }
    GNUNET_assert (0 < sscanf_ret);
    node_connection->namespace_n = namespace_n;
    token = strtok_r (NULL, ":", &rest);
    errno = 0;
    sscanf_ret = sscanf (token, "%u", &node_n);
    if (errno != 0)
    {
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
    }
    GNUNET_assert (0 < sscanf_ret);
    node_connection->node_n = node_n;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "node_n %u namespace_n %u node->node_n %u node->namespace_n %u\n",
         node_n,
         namespace_n,
         node->node_n,
         node->namespace_n);
  }
  else
  {
    GNUNET_break (0);
    GNUNET_free (node_connection);
    GNUNET_free (copy);
    return NULL;
  }
 
  while (NULL != (token = strtok_r (NULL, ":", &rest)))
  {
    prefix = GNUNET_new (struct GNUNET_TESTING_AddressPrefix);
    token2 = strtok_r (token, "}", &rest2);
    if (NULL != token2)
      prefix->address_prefix = GNUNET_strdup (token2);
    else
      prefix->address_prefix = GNUNET_strdup (token);
 
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "address_prefix %s\n",
         prefix->address_prefix);
 
    GNUNET_CONTAINER_DLL_insert (node_connection->address_prefixes_head,
                                 node_connection->address_prefixes_tail,
                                 prefix);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "address_prefix %s\n",
         prefix->address_prefix);
  }
 
  GNUNET_free (copy);
  return node_connection;
}

References GNUNET_TESTING_NodeConnection::address_prefixes_head, GNUNET_TESTING_NodeConnection::address_prefixes_tail, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_strerror, GNUNET_new, GNUNET_strdup, GNUNET_TESTING_GLOBAL_NODE, GNUNET_TESTING_SUBNET_NODE, line, LOG, GNUNET_TESTING_NodeConnection::namespace_n, GNUNET_TESTING_NetjailNode::namespace_n, GNUNET_TESTING_NodeConnection::node, GNUNET_TESTING_NodeConnection::node_n, GNUNET_TESTING_NetjailNode::node_n, GNUNET_TESTING_NodeConnection::node_type, and prefix.

Referenced by node_connections().

Here is the caller graph for this function:

◆ node_connections()

static void node_connections	(	const char *	line,
		struct GNUNET_TESTING_NetjailNode *	node
	)

static

Every line in the topology configuration starts with a string indicating which kind of information will be configured with this line.

Configuration values following this string are seperated by special sequences of characters. A value might be a key value pair. A special key is the 'connect' key. The value is the information about a connections via some protocol to other nodes. Each connection itself is a key value pair separated by the character '|' and surrounded by the characters '{' and '}'. The struct GNUNET_TESTING_NodeConnection holds the information of each connection value. This function extracts the values of each connection into a DLL of struct GNUNET_TESTING_NodeConnection which will be added to a node.

Parameters

line	The line of configuration.
node	The struct GNUNET_TESTING_NetjailNode to which the DLL of struct GNUNET_TESTING_NodeConnection will be added.

Definition at line 2006 of file testing.c.

{
  char *value, *value2;
  char *temp;
  char *copy;
  char *rest = NULL;
  char *rest2 = NULL;
  struct GNUNET_TESTING_NodeConnection *node_connection;
 
 
  temp = strstr (line, "connect");
  if (NULL != temp)
  {
    copy = GNUNET_strdup (temp);
    strtok_r (copy, ":", &rest);
    value = strtok_r (rest, "|", &rest2);
 
    while (NULL != value)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "node_connections value %s\n",
           value);
      node_connection = get_connect_value (value, node);
      if (NULL == node_connection)
      {
        LOG (GNUNET_ERROR_TYPE_WARNING,
             "connect key was not expected in this configuration line: %s\n",
             line);
        break;
      }
      GNUNET_CONTAINER_DLL_insert (node->node_connections_head,
                                   node->node_connections_tail,
                                   node_connection);
      value2 = strstr (value, "}}");
      if (NULL != value2)
        break;
      value = strtok_r (NULL, "|", &rest2);
 
    }
    GNUNET_free (copy);
  }
}

References get_connect_value(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_strdup, line, LOG, GNUNET_TESTING_NodeConnection::node, GNUNET_TESTING_NetjailNode::node_connections_head, GNUNET_TESTING_NetjailNode::node_connections_tail, and value.

Referenced by get_node_info(), GNUNET_TESTING_get_additional_connects(), GNUNET_TESTING_get_connections(), GNUNET_TESTING_get_node(), and GNUNET_TESTING_get_topo_from_string().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ log_nodes()

static int log_nodes	(	void *	cls,
		const struct GNUNET_ShortHashCode *	id,
		void *	value
	)

static

A helper function to log information about individual nodes.

Parameters

cls	This is not used actually.
id	The key of this value in the map.
value	A struct GNUNET_TESTING_NetjailNode which holds information about a node. return GNUNET_YES to continue with iterating, GNUNET_NO otherwise.

Definition at line 2059 of file testing.c.

{
  struct GNUNET_TESTING_NetjailNode *node = value;
  struct GNUNET_TESTING_NodeConnection *pos_connection;
  struct GNUNET_TESTING_AddressPrefix *pos_prefix;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "plugin: %s space: %u node: %u global: %u\n",
       node->plugin,
       node->namespace_n,
       node->node_n,
       node->is_global);
 
  for (pos_connection = node->node_connections_head; NULL != pos_connection;
       pos_connection = pos_connection->next)
  {
 
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "namespace_n: %u node_n: %u node_type: %u\n",
         pos_connection->namespace_n,
         pos_connection->node_n,
         pos_connection->node_type);
 
    for (pos_prefix = pos_connection->address_prefixes_head; NULL != pos_prefix;
         pos_prefix =
           pos_prefix->next)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "prefix: %s\n",
           pos_prefix->address_prefix);
    }
  }
  return GNUNET_YES;
}

References GNUNET_TESTING_AddressPrefix::address_prefix, GNUNET_TESTING_NodeConnection::address_prefixes_head, GNUNET_ERROR_TYPE_DEBUG, GNUNET_YES, GNUNET_TESTING_NetjailNode::is_global, LOG, GNUNET_TESTING_NodeConnection::namespace_n, GNUNET_TESTING_NetjailNode::namespace_n, GNUNET_TESTING_AddressPrefix::next, GNUNET_TESTING_NodeConnection::next, GNUNET_TESTING_NetjailNode::node_connections_head, GNUNET_TESTING_NodeConnection::node_n, GNUNET_TESTING_NetjailNode::node_n, GNUNET_TESTING_NodeConnection::node_type, GNUNET_TESTING_NetjailNode::plugin, and value.

Referenced by log_namespaces(), and log_topo().

Here is the caller graph for this function:

◆ log_namespaces()

static int log_namespaces	(	void *	cls,
		const struct GNUNET_ShortHashCode *	id,
		void *	value
	)

static

Helper function to log information about namespaces.

Parameters

cls	This is not used actually.
id	The key of this value in the map.
value	A struct GNUNET_TESTING_NetjailNamespace which holds information about a subnet. return GNUNET_YES to continue with iterating, GNUNET_NO otherwise.

Definition at line 2104 of file testing.c.

{
  struct GNUNET_TESTING_NetjailNamespace *namespace = value;
 
  GNUNET_CONTAINER_multishortmap_iterate (namespace->nodes, &log_nodes, NULL);
  return GNUNET_YES;
}

References GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_YES, log_nodes(), and value.

Referenced by log_topo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ log_topo()

static int log_topo ( const struct GNUNET_TESTING_NetjailTopology * topology )

static

Helper function to log the configuration in case of a problem with configuration.

Parameters

topology The struct GNUNET_TESTING_NetjailTopology holding the configuration information.

Definition at line 2119 of file testing.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "plugin: %s spaces: %u nodes: %u known: %u\n",
       topology->plugin,
       topology->namespaces_n,
       topology->nodes_m,
       topology->nodes_x);
 
  GNUNET_CONTAINER_multishortmap_iterate (topology->map_namespaces,
                                          log_namespaces, NULL);
  GNUNET_CONTAINER_multishortmap_iterate (topology->map_globals, &log_nodes,
                                          NULL);
  return GNUNET_YES;
}

References GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_YES, LOG, log_namespaces(), log_nodes(), GNUNET_TESTING_NetjailTopology::map_globals, GNUNET_TESTING_NetjailTopology::map_namespaces, GNUNET_TESTING_NetjailTopology::namespaces_n, GNUNET_TESTING_NetjailTopology::nodes_m, GNUNET_TESTING_NetjailTopology::nodes_x, and GNUNET_TESTING_NetjailTopology::plugin.

Referenced by get_node_info().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_node_info()

static void get_node_info	(	unsigned int	num,
		const struct GNUNET_TESTING_NetjailTopology *	topology,
		struct GNUNET_TESTING_NetjailNode **	node_ex,
		struct GNUNET_TESTING_NetjailNamespace **	namespace_ex,
		struct GNUNET_TESTING_NodeConnection **	node_connections_ex
	)

static

This function extracts information about a specific node from the topology.

Parameters

	num	The global index number of the node.
[out]	node_ex	A struct GNUNET_TESTING_NetjailNode with information about the node.
[out]	namespace_ex	A struct GNUNET_TESTING_NetjailNamespace with information about the namespace the node is in or NULL, if the node is a global node.
[out]	node_connections_ex	A struct GNUNET_TESTING_NodeConnection with information about the connection of this node to other nodes.

Definition at line 2147 of file testing.c.

{
  struct GNUNET_ShortHashCode hkey;
  struct GNUNET_HashCode hc;
  unsigned int namespace_n;
  unsigned int node_m;
  struct GNUNET_TESTING_NetjailNode *node;
  struct GNUNET_TESTING_NetjailNamespace *namespace;
  struct GNUNET_TESTING_NodeConnection *node_connections = NULL;
 
  log_topo (topology);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "num: %u \n",
       num);
  if (topology->nodes_x >= num)
  {
 
    GNUNET_CRYPTO_hash (&num, sizeof(num), &hc);
    memcpy (&hkey,
            &hc,
            sizeof (hkey));
    node = GNUNET_CONTAINER_multishortmap_get (topology->map_globals,
                                               &hkey);
    if (NULL != node)
    {
      *node_ex = node;
      *node_connections_ex = node->node_connections_head;
    }
  }
  else
  {
    namespace_n = (unsigned int) ceil ((double) (num - topology->nodes_x)
                                       / topology->nodes_m);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "ceil num: %u nodes_x: %u nodes_m: %u namespace_n: %u\n",
         num,
         topology->nodes_x,
         topology->nodes_m,
         namespace_n);
    GNUNET_CRYPTO_hash (&namespace_n, sizeof(namespace_n), &hc);
    memcpy (&hkey,
            &hc,
            sizeof (hkey));
    namespace = GNUNET_CONTAINER_multishortmap_get (topology->map_namespaces,
                                                    &hkey);
    if (NULL != namespace)
    {
      node_m = num - topology->nodes_x - topology->nodes_m * (namespace_n - 1);
      GNUNET_CRYPTO_hash (&node_m, sizeof(node_m), &hc);
      memcpy (&hkey,
              &hc,
              sizeof (hkey));
      node = GNUNET_CONTAINER_multishortmap_get (namespace->nodes,
                                                 &hkey);
      if (NULL != node)
      {
        LOG (GNUNET_ERROR_TYPE_DEBUG,
             "node additional_connects: %u %p\n",
             node->additional_connects,
             node);
        node_connections = node->node_connections_head;
      }
      *node_ex = node;
      *namespace_ex = namespace;
      *node_connections_ex = node_connections;
    }
  }
}

References GNUNET_TESTING_NetjailNode::additional_connects, GNUNET_CONTAINER_multishortmap_get(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, consensus-simulation::int, LOG, log_topo(), GNUNET_TESTING_NetjailTopology::map_globals, GNUNET_TESTING_NodeConnection::namespace_n, GNUNET_TESTING_NodeConnection::node, node_connections(), GNUNET_TESTING_NetjailNode::node_connections_head, GNUNET_TESTING_NetjailTopology::nodes_m, and GNUNET_TESTING_NetjailTopology::nodes_x.

Referenced by GNUNET_TESTING_get_additional_connects(), GNUNET_TESTING_get_connections(), and GNUNET_TESTING_get_node().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_TESTING_get_node()

struct GNUNET_TESTING_NetjailNode * GNUNET_TESTING_get_node	(	unsigned int	num,
		struct GNUNET_TESTING_NetjailTopology *	topology
	)

Get a node from the topology.

Parameters

num	The specific node we want the connections for.
topology	The topology we get the connections from.

Returns: The connections of the node.

Definition at line 2229 of file testing.c.

{
  struct GNUNET_TESTING_NetjailNode *node;
  struct GNUNET_TESTING_NetjailNamespace *namespace;
  struct GNUNET_TESTING_NodeConnection *node_connections;
 
  get_node_info (num, topology, &node, &namespace, &node_connections);
 
  return node;
 
}

References get_node_info(), GNUNET_TESTING_NodeConnection::node, and node_connections().

Here is the call graph for this function:

◆ GNUNET_TESTING_get_connections()

struct GNUNET_TESTING_NodeConnection * GNUNET_TESTING_get_connections	(	unsigned int	num,
		const struct GNUNET_TESTING_NetjailTopology *	topology
	)

Get the connections to other nodes for a specific node.

Parameters

num	The specific node we want the connections for.
topology	The topology we get the connections from.

Returns: The connections of the node.

Definition at line 2251 of file testing.c.

{
  struct GNUNET_TESTING_NetjailNode *node;
  struct GNUNET_TESTING_NetjailNamespace *namespace;
  struct GNUNET_TESTING_NodeConnection *node_connections;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "get_connections\n");
 
  get_node_info (num, topology, &node, &namespace, &node_connections);
 
  return node_connections;
}

References get_node_info(), GNUNET_ERROR_TYPE_DEBUG, LOG, GNUNET_TESTING_NodeConnection::node, and node_connections().

Referenced by backchannel_check_run(), and connect_peers_run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_TESTING_get_peer()

struct GNUNET_PeerIdentity * GNUNET_TESTING_get_peer	(	unsigned int	num,
		const struct GNUNET_TESTING_System *	tl_system
	)

Retrieve the peer identity from the test system with the unique node id.

Retrieve peer identity from the test system with the unique node id.

Parameters

num	The unique node id.
tl_system	The test system.

Returns: The peer identity wrapping the public key.

Definition at line 2276 of file testing.c.

{
  struct GNUNET_PeerIdentity *peer = GNUNET_new (struct GNUNET_PeerIdentity);
  struct GNUNET_CRYPTO_EddsaPrivateKey *priv_key;
 
  priv_key = GNUNET_TESTING_hostkey_get (tl_system,
                                         num,
                                         peer);
 
  GNUNET_CRYPTO_eddsa_key_get_public (priv_key,
                                      &peer->public_key);
  GNUNET_free (priv_key);
  return peer;
}

References GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_free, GNUNET_new, GNUNET_TESTING_hostkey_get(), and GNUNET_PeerIdentity::public_key.

Referenced by add_search_string(), connect_peers_run(), join_room_run(), and notify_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ free_nodes_cb()

int free_nodes_cb	(	void *	cls,
		const struct GNUNET_ShortHashCode *	key,
		void *	value
	)

Definition at line 2294 of file testing.c.

{
  (void) cls;
  struct GNUNET_TESTING_NetjailNode *node = value;
  struct GNUNET_TESTING_NodeConnection *pos_connection;
  struct GNUNET_TESTING_AddressPrefix *pos_prefix;
 
  while (NULL != (pos_connection = node->node_connections_head))
  {
    while (NULL != (pos_prefix = pos_connection->address_prefixes_head))
    {
      GNUNET_CONTAINER_DLL_remove (pos_connection->address_prefixes_head,
                                   pos_connection->address_prefixes_tail,
                                   pos_prefix);
      GNUNET_free (pos_prefix->address_prefix);
      GNUNET_free (pos_prefix);
    }
    GNUNET_CONTAINER_DLL_remove (node->node_connections_head,
                                 node->node_connections_tail,
                                 pos_connection);
    GNUNET_free (pos_connection);
  }
 
  GNUNET_free (node->plugin);
  GNUNET_free (node);
  return GNUNET_OK;
}

References GNUNET_TESTING_AddressPrefix::address_prefix, GNUNET_TESTING_NodeConnection::address_prefixes_head, GNUNET_TESTING_NodeConnection::address_prefixes_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_OK, GNUNET_TESTING_NetjailNode::node_connections_head, GNUNET_TESTING_NetjailNode::node_connections_tail, GNUNET_TESTING_NetjailNode::plugin, and value.

Referenced by free_namespaces_cb(), and GNUNET_TESTING_free_topology().

Here is the caller graph for this function:

◆ free_namespaces_cb()

int free_namespaces_cb	(	void *	cls,
		const struct GNUNET_ShortHashCode *	key,
		void *	value
	)

Definition at line 2326 of file testing.c.

{
  (void) cls;
  struct GNUNET_TESTING_NetjailNamespace *namespace = value;
 
  GNUNET_free (namespace->router);
  GNUNET_CONTAINER_multishortmap_iterate (namespace->nodes, free_nodes_cb,
                                          namespace->nodes);
  return GNUNET_OK;
 
}

References free_nodes_cb(), GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_free, GNUNET_OK, and value.

Referenced by GNUNET_TESTING_free_topology().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_TESTING_free_topology()

void GNUNET_TESTING_free_topology ( struct GNUNET_TESTING_NetjailTopology * topology )

Deallocate memory of the struct GNUNET_TESTING_NetjailTopology.

Parameters

topology The GNUNET_TESTING_NetjailTopology to be deallocated.

Definition at line 2347 of file testing.c.

{
  GNUNET_CONTAINER_multishortmap_iterate (topology->map_namespaces,
                                          free_namespaces_cb, NULL);
  GNUNET_CONTAINER_multishortmap_destroy (topology->map_namespaces);
  GNUNET_CONTAINER_multishortmap_iterate (topology->map_globals, free_nodes_cb,
                                          NULL);
  GNUNET_CONTAINER_multishortmap_destroy (topology->map_globals);
  GNUNET_free (topology->plugin);
  GNUNET_free (topology);
}

References free_namespaces_cb(), free_nodes_cb(), GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_free, GNUNET_TESTING_NetjailTopology::map_globals, GNUNET_TESTING_NetjailTopology::map_namespaces, and GNUNET_TESTING_NetjailTopology::plugin.

Here is the call graph for this function:

◆ GNUNET_TESTING_calculate_num()

unsigned int GNUNET_TESTING_calculate_num	(	struct GNUNET_TESTING_NodeConnection *	node_connection,
		struct GNUNET_TESTING_NetjailTopology *	topology
	)

Calculate the unique id identifying a node from a given connection.

Parameters

node_connection	The connection we calculate the id from.
topology	The topology we get all needed information from.

Returns: The unique id of the node from the connection.

Definition at line 2361 of file testing.c.

{
  unsigned int n, m, num;
 
  n = node_connection->namespace_n;
  m = node_connection->node_n;
 
  if (0 == n)
    num = m;
  else
    num = (n - 1) * topology->nodes_m + m + topology->nodes_x;
 
  return num;
}

References m, GNUNET_TESTING_NodeConnection::namespace_n, GNUNET_TESTING_NodeConnection::node_n, GNUNET_TESTING_NetjailTopology::nodes_m, and GNUNET_TESTING_NetjailTopology::nodes_x.

Referenced by connect_peers_run(), and notify_connect().

Here is the caller graph for this function:

◆ GNUNET_TESTING_get_address()

char * GNUNET_TESTING_get_address	(	struct GNUNET_TESTING_NodeConnection *	connection,
		const char *	prefix
	)

Get the address for a specific communicator from a connection.

Parameters

connection	The connection we like to have the address from.
prefix	The communicator protocol prefix.

Returns: The address of the communicator.

Definition at line 2387 of file testing.c.

{
  struct GNUNET_TESTING_NetjailNode *node;
  char *addr;
  char *template;
  unsigned int node_n;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "get address prefix: %s node_n: %u\n",
       prefix,
       connection->node_n);
 
  node = connection->node;
  if (connection->namespace_n == node->namespace_n)
  {
    template = CONNECT_ADDRESS_TEMPLATE;
    node_n = connection->node_n;
  }
  else if (0 == connection->namespace_n)
  {
    template = KNOWN_CONNECT_ADDRESS_TEMPLATE;
    node_n = connection->node_n;
  }
  else if (1 == connection->node_n)
  {
    template = ROUTER_CONNECT_ADDRESS_TEMPLATE;
    node_n = connection->namespace_n;
  }
  else
  {
    return NULL;
  }
 
  if (0 == strcmp (PREFIX_TCP, prefix) ||
      0 == strcmp (PREFIX_UDP, prefix) ||
      0 == strcmp (PREFIX_UDP_NATTED, prefix) ||
      0 == strcmp (PREFIX_TCP_NATTED, prefix))
  {
    GNUNET_asprintf (&addr,
                     template,
                     prefix,
                     node_n);
  }
  else
  {
    GNUNET_assert (0);
  }
 
  return addr;
}

References CONNECT_ADDRESS_TEMPLATE, GNUNET_asprintf(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, KNOWN_CONNECT_ADDRESS_TEMPLATE, LOG, GNUNET_TESTING_NodeConnection::namespace_n, GNUNET_TESTING_NetjailNode::namespace_n, GNUNET_TESTING_NodeConnection::node, GNUNET_TESTING_NodeConnection::node_n, GNUNET_TESTING_NetjailNode::node_n, prefix, PREFIX_TCP, PREFIX_TCP_NATTED, PREFIX_UDP, PREFIX_UDP_NATTED, and ROUTER_CONNECT_ADDRESS_TEMPLATE.

Referenced by connect_peers_run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_TESTING_get_additional_connects()

unsigned int GNUNET_TESTING_get_additional_connects	(	unsigned int	num,
		struct GNUNET_TESTING_NetjailTopology *	topology
	)

Get the number of unintentional additional connections the node waits for.

Parameters

num	The specific node we want the additional connects for.

Returns: The number of additional connects

Definition at line 2447 of file testing.c.

{
  struct GNUNET_TESTING_NetjailNode *node;
  struct GNUNET_TESTING_NetjailNamespace *namespace;
  struct GNUNET_TESTING_NodeConnection *node_connections;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "get_additional_connects\n");
 
  get_node_info (num, topology, &node, &namespace, &node_connections);
 
  if (NULL == node)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "No info found for node %d\n", num);
    return 0;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "node additional_connects for node %p\n",
       node);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "node additional_connects: %u\n",
       node->additional_connects);
 
  return node->additional_connects;
}

References GNUNET_TESTING_NetjailNode::additional_connects, get_node_info(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, LOG, and node_connections().

Referenced by GNUNET_CORE_cmd_connect_peers(), and GNUNET_TRANSPORT_cmd_connect_peers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ parse_ac()

static void parse_ac	(	struct GNUNET_TESTING_NetjailNode *	p_node,
		const char *	token
	)

static

Definition at line 2478 of file testing.c.

{
  char *ac_value;
  int ret;
 
  ac_value = get_value ("AC", token);
  if (NULL != ac_value)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "ac value: %s\n",
         ac_value);
    errno = 0;
    ret = sscanf (ac_value, "%u", &p_node->additional_connects);
    if (errno != 0)
    {
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "sscanf");
    }
    GNUNET_assert (0 < ret);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "AC %u\n",
         p_node->additional_connects);
  }
  else
  {
    p_node->additional_connects = 0;
  }
  GNUNET_free (ac_value);
}

References GNUNET_TESTING_NetjailNode::additional_connects, get_value(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_strerror, LOG, and ret.

Referenced by GNUNET_TESTING_get_topo_from_string().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_TESTING_get_topo_from_string()

struct GNUNET_TESTING_NetjailTopology * GNUNET_TESTING_get_topo_from_string ( const char * input )

Parse the topology data.

FIXME: this could use a "to_string".

Parameters

data	The topology data.

Returns: The GNUNET_TESTING_NetjailTopology

Definition at line 2515 of file testing.c.

{
  char *token;
  char *key = NULL;
  unsigned int out;
  char *rest = NULL;
  char *value = NULL;
  char *value2;
  char *data;
  int ret;
  struct GNUNET_TESTING_NetjailTopology *topo;
  struct GNUNET_TESTING_NetjailRouter *router;
  struct GNUNET_TESTING_NetjailNamespace *namespace;
  struct GNUNET_HashCode hc;
 
  data = GNUNET_strdup (input);
  token = strtok_r (data, "\n", &rest);
  topo = GNUNET_new (struct GNUNET_TESTING_NetjailTopology);
  topo->map_namespaces =
    GNUNET_CONTAINER_multishortmap_create (1,GNUNET_NO);
  topo->map_globals =
    GNUNET_CONTAINER_multishortmap_create (1,GNUNET_NO);
 
  while (NULL != token)
  {
    if (NULL != key)
      GNUNET_free (key);
    key = get_key (token);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "In the loop with token: %s beginning with %s\n",
         token,
         key);
    if (0 == strcmp (key, "M"))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Get first Value for M.\n");
      out = get_first_value (token);
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "M: %u\n",
           out);
      topo->nodes_m = out;
    }
    else if (0 == strcmp (key, "N"))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Get first Value for N.\n");
      out = get_first_value (token);
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "N: %u\n",
           out);
      topo->namespaces_n = out;
    }
    else if (0 == strcmp (key, "X"))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Get first Value for X.\n");
      out = get_first_value (token);
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "X: %u\n",
           out);
      topo->nodes_x = out;
    }
    else if (0 == strcmp (key, "AC"))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Get first Value for AC.\n");
      out = get_first_value (token);
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "AC: %u\n",
           out);
      topo->additional_connects = out;
    }
    else if (0 == strcmp (key, "T"))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Get first string value for T.\n");
      value = get_first_string_value (token);
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "value: %s\n",
           value);
      topo->plugin = value;
    }
    else if (0 == strcmp (key, "K"))
    {
      struct GNUNET_ShortHashCode hkey_k;
      struct GNUNET_TESTING_NetjailNode *k_node = GNUNET_new (struct
                                                              GNUNET_TESTING_NetjailNode);
 
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Get first Value for K.\n");
      out = get_first_value (token);
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "K: %u\n",
           out);
      k_node->node_n = out;
      GNUNET_CRYPTO_hash (&out, sizeof(out), &hc);
      memcpy (&hkey_k,
              &hc,
              sizeof (hkey_k));
      k_node->is_global = GNUNET_YES;
 
      if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_contains (
            topo->map_globals,
            &hkey_k))
        GNUNET_break (0);
      else
        GNUNET_CONTAINER_multishortmap_put (topo->map_globals,
                                            &hkey_k,
                                            k_node,
                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Get value for key value on K.\n");
      value = get_value ("plugin", token);
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "value: %s\n",
           value);
      k_node->plugin = value;
      parse_ac (k_node, token);
      node_connections (token, k_node);
      GNUNET_free (value);
    }
    else if (0 == strcmp (key, "R"))
    {
      struct GNUNET_ShortHashCode hkey_r;
      router = GNUNET_new (struct GNUNET_TESTING_NetjailRouter);
 
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Get first Value for R.\n");
      out = get_first_value (token);
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "R: %u\n",
           out);
      GNUNET_CRYPTO_hash (&out, sizeof(out), &hc);
      memcpy (&hkey_r,
              &hc,
              sizeof (hkey_r));
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Get value for key tcp_port on R.\n");
      value = get_value ("tcp_port", token);
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "tcp_port: %s\n",
           value);
      ret = sscanf (value, "%u", &(router->tcp_port));
      GNUNET_free (value);
      GNUNET_break (0 != ret && 1 >= router->tcp_port);
 
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Get value for key udp_port on R.\n");
      value2 = get_value ("udp_port", token);
      ret = sscanf (value2, "%u", &(router->udp_port));
      GNUNET_free (value2);
      GNUNET_break (0 != ret && 1 >= router->udp_port);
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "udp_port: %s\n",
           value2);
      GNUNET_free (value2);
      if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_contains (
            topo->map_namespaces,
            &hkey_r))
      {
        namespace = GNUNET_CONTAINER_multishortmap_get (topo->map_namespaces,
                                                        &hkey_r);
      }
      else
      {
        namespace = GNUNET_new (struct GNUNET_TESTING_NetjailNamespace);
        namespace->namespace_n = out;
        namespace->nodes = GNUNET_CONTAINER_multishortmap_create (1,GNUNET_NO);
        GNUNET_CONTAINER_multishortmap_put (topo->map_namespaces,
                                            &hkey_r,
                                            namespace,
                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
      }
      namespace->router = router;
 
    }
    else if (0 == strcmp (key, "P"))
    {
      struct GNUNET_TESTING_NetjailNode *p_node = GNUNET_new (struct
                                                              GNUNET_TESTING_NetjailNode);
      struct GNUNET_ShortHashCode hkey_p;
 
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Get first Value for P.\n");
      out = get_first_value (token);
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "P: %u\n",
           out);
      GNUNET_CRYPTO_hash (&out, sizeof(out), &hc);
      memcpy (&hkey_p,
              &hc,
              sizeof (hkey_p));
 
      if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_contains (
            topo->map_namespaces,
            &hkey_p))
      {
        namespace = GNUNET_CONTAINER_multishortmap_get (topo->map_namespaces,
                                                        &hkey_p);
      }
      else
      {
        namespace = GNUNET_new (struct GNUNET_TESTING_NetjailNamespace);
        namespace->nodes = GNUNET_CONTAINER_multishortmap_create (1,GNUNET_NO);
        namespace->namespace_n = out;
        GNUNET_CONTAINER_multishortmap_put (topo->map_namespaces,
                                            &hkey_p,
                                            namespace,
                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
      }
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Get second Value for P.\n");
      out = get_second_value (token);
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "P: %u\n",
           out);
      GNUNET_CRYPTO_hash (&out, sizeof(out), &hc);
      memcpy (&hkey_p,
              &hc,
              sizeof (hkey_p));
      if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_contains (
            namespace->nodes,
            &hkey_p))
      {
        GNUNET_break (0);
      }
      else
      {
 
        GNUNET_CONTAINER_multishortmap_put (namespace->nodes,
                                            &hkey_p,
                                            p_node,
                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
        LOG (GNUNET_ERROR_TYPE_DEBUG,
             "Get value for key plugin on P.\n");
        value = get_value ("plugin", token);
        if (NULL != value)
        {
          LOG (GNUNET_ERROR_TYPE_DEBUG,
               "plugin: %s\n",
               value);
          p_node->plugin = value;
        }
        p_node->node_n = out;
        p_node->namespace_n = namespace->namespace_n;
      }
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Get AC Value for P.\n");
      parse_ac (p_node, token);
      node_connections (token, p_node);
    }
    token = strtok_r (NULL, "\n", &rest);
    if (NULL != token)
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Next token %s\n",
           token);
  }
  if (NULL != key)
    GNUNET_free (key);
  GNUNET_free (data);
  return topo;
}

Referenced by GNUNET_TESTING_get_topo_from_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_TESTING_get_topo_from_file()

struct GNUNET_TESTING_NetjailTopology * GNUNET_TESTING_get_topo_from_file ( const char * filename )

Getting the topology from file.

Parameters

filename The name of the topology file.

Returns: The GNUNET_TESTING_NetjailTopology

Definition at line 2786 of file testing.c.

{
  uint64_t fs;
  char *data;
  struct GNUNET_TESTING_NetjailTopology *topo;
 
  if (GNUNET_YES != GNUNET_DISK_file_test (filename))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Topology file %s not found\n"),
         filename);
    return NULL;
  }
  if (GNUNET_OK !=
      GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Topology file %s has no data\n"),
         filename);
    return NULL;
  }
  data = GNUNET_malloc (fs + 1);
  if (fs != GNUNET_DISK_fn_read (filename, data, fs))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Topology file %s cannot be read\n"),
         filename);
    GNUNET_free (data);
    return NULL;
  }
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "file length %" PRIu64 "\n",
       fs);
  data[fs] = '\0';
 
  topo = GNUNET_TESTING_get_topo_from_string (data);
 
  GNUNET_free (data);
 
  return topo;
}

References _, data, filename, fs, GNUNET_DISK_file_size(), GNUNET_DISK_file_test(), GNUNET_DISK_fn_read(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_TESTING_get_topo_from_string(), GNUNET_YES, and LOG.

Here is the call graph for this function:

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ LOG

◆ CONNECT_ADDRESS_TEMPLATE

◆ ROUTER_CONNECT_ADDRESS_TEMPLATE

◆ KNOWN_CONNECT_ADDRESS_TEMPLATE

◆ PREFIX_TCP

◆ PREFIX_UDP

◆ PREFIX_TCP_NATTED

◆ PREFIX_UDP_NATTED

◆ LOW_PORT

◆ HIGH_PORT

Function Documentation

◆ hostkeys_load()

◆ hostkeys_unload()

◆ cfg_copy_iterator()

◆ cleanup_shared_service_instance()

◆ start_shared_service_instance()

◆ stop_shared_service_instance()

◆ update_config()

◆ update_config_sections()

◆ associate_shared_service()

◆ GNUNET_TESTING_configuration_create_()

◆ disconn_status()

◆ service_run_main()

◆ get_first_value()

◆ get_key()

◆ get_first_string_value()

◆ get_second_value()

◆ get_value()

◆ get_connect_value()

◆ node_connections()

◆ log_nodes()

◆ log_namespaces()

◆ log_topo()

◆ get_node_info()

◆ GNUNET_TESTING_get_node()

◆ GNUNET_TESTING_get_connections()

◆ GNUNET_TESTING_get_peer()

◆ free_nodes_cb()

◆ free_namespaces_cb()

◆ GNUNET_TESTING_free_topology()

◆ GNUNET_TESTING_calculate_num()

◆ GNUNET_TESTING_get_address()

◆ GNUNET_TESTING_get_additional_connects()

◆ parse_ac()

◆ GNUNET_TESTING_get_topo_from_string()

◆ GNUNET_TESTING_get_topo_from_file()