testing_api_topology.c File Reference

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_testing_lib.h"
#include "testing_api_topology.h"
#include "testing_cmds.h"

Include dependency graph for testing_api_topology.c:

Go to the source code of this file.

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"

Functions
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...
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)
static int	free_value_cb (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
static int	free_subnets_cb (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
static int	free_carriers_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)
	Deallocate memory of the struct GNUNET_TESTING_NetjailTopology. 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...
char *	GNUNET_TESTING_get_plugin_from_topo (struct GNUNET_TESTING_NetjailTopology *njt, const char *my_node_id)
	Get the global plugin name form the topology file. More...
static void	create_subnet_peers (struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_TESTING_NetjailTopology *topology, struct GNUNET_TESTING_NetjailSubnet *subnet)
static void	create_subnets (struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_TESTING_NetjailTopology *topology, struct GNUNET_TESTING_NetjailCarrier *carrier)
static void	create_peers (struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_TESTING_NetjailTopology *topology, struct GNUNET_TESTING_NetjailCarrier *carrier)
struct GNUNET_TESTING_NetjailTopology *	GNUNET_TESTING_get_topo_from_string_ (const char *input)
	Parse the topology data. More...

Macro Definition Documentation

LOG

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

Definition at line 38 of file testing_api_topology.c.

CONNECT_ADDRESS_TEMPLATE

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

Definition at line 40 of file testing_api_topology.c.

ROUTER_CONNECT_ADDRESS_TEMPLATE

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

Definition at line 42 of file testing_api_topology.c.

KNOWN_CONNECT_ADDRESS_TEMPLATE

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

Definition at line 44 of file testing_api_topology.c.

PREFIX_TCP

#define PREFIX_TCP   "tcp"

Definition at line 46 of file testing_api_topology.c.

PREFIX_UDP

#define PREFIX_UDP   "udp"

Definition at line 48 of file testing_api_topology.c.

PREFIX_TCP_NATTED

#define PREFIX_TCP_NATTED   "tcp_natted"

Definition at line 50 of file testing_api_topology.c.

PREFIX_UDP_NATTED

#define PREFIX_UDP_NATTED   "udp_natted"

Definition at line 52 of file testing_api_topology.c.

Function Documentation

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 64 of file testing_api_topology.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 111 of file testing_api_topology.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 130 of file testing_api_topology.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 158 of file testing_api_topology.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, 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 240 of file testing_api_topology.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(), and GNUNET_TESTING_NodeConnection::node.

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 262 of file testing_api_topology.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, and GNUNET_TESTING_NodeConnection::node.

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:

free_nodes_cb()

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

Definition at line 280 of file testing_api_topology.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().

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 312 of file testing_api_topology.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.

Here is the call graph for this function:

free_value_cb()

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

static

Definition at line 328 of file testing_api_topology.c.

{
  (void) cls;
 
  GNUNET_free (value);
 
  return GNUNET_OK;
}

References GNUNET_free, GNUNET_OK, and value.

Referenced by free_carriers_cb(), free_subnets_cb(), and GNUNET_TESTING_free_topology().

Here is the caller graph for this function:

free_subnets_cb()

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

static

Definition at line 341 of file testing_api_topology.c.

{
  (void) cls;
  struct GNUNET_TESTING_NetjailSubnet *subnet = value;
 
  GNUNET_CONTAINER_multishortmap_iterate (subnet->peers,
                                          &free_value_cb,
                                          NULL);
 
  GNUNET_free (subnet);
 
  return GNUNET_OK;
}

References free_value_cb(), GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_free, GNUNET_OK, GNUNET_TESTING_NetjailSubnet::peers, and value.

Referenced by free_carriers_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

free_carriers_cb()

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

static

Definition at line 359 of file testing_api_topology.c.

{
  (void) cls;
  struct GNUNET_TESTING_NetjailCarrier *carrier = value;
 
  GNUNET_CONTAINER_multishortmap_iterate (carrier->peers,
                                          &free_value_cb,
                                          NULL);
  GNUNET_CONTAINER_multishortmap_iterate (carrier->subnets,
                                          &free_subnets_cb,
                                          NULL);
 
  GNUNET_free (carrier);
 
  return GNUNET_OK;
}

References free_subnets_cb(), free_value_cb(), GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_free, GNUNET_OK, GNUNET_TESTING_NetjailCarrier::peers, GNUNET_TESTING_NetjailCarrier::subnets, 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 385 of file testing_api_topology.c.

{
  GNUNET_CONTAINER_multishortmap_iterate (topology->backbone_peers,
                                          &free_value_cb,
                                          NULL);
  GNUNET_CONTAINER_multishortmap_iterate (topology->carriers,
                                          &free_carriers_cb,
                                          NULL);
  GNUNET_free (topology->plugin);
  GNUNET_free (topology);
}

References GNUNET_TESTING_NetjailTopology::backbone_peers, GNUNET_TESTING_NetjailTopology::carriers, free_carriers_cb(), free_value_cb(), GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_free, and GNUNET_TESTING_NetjailTopology::plugin.

Referenced by cleanup(), do_shutdown(), and netjail_exec_run().

Here is the call graph for this function:

Here is the caller 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
	)

Deallocate memory of the struct GNUNET_TESTING_NetjailTopology.

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

Parameters

topology

The GNUNET_TESTING_NetjailTopology to be deallocated.

void GNUNET_TESTING_free_topology (struct GNUNET_TESTING_NetjailTopology *topology) { 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); }

Definition at line 420 of file testing_api_topology.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 446 of file testing_api_topology.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 506 of file testing_api_topology.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, and LOG.

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:

GNUNET_TESTING_get_plugin_from_topo()

char * GNUNET_TESTING_get_plugin_from_topo	(	struct GNUNET_TESTING_NetjailTopology *	njt,
		const char *	my_node_id
	)

Get the global plugin name form the topology file.

Definition at line 536 of file testing_api_topology.c.

{
  return njt->plugin;
}

References njt, and GNUNET_TESTING_NetjailTopology::plugin.

Referenced by handle_helper_init().

Here is the caller graph for this function:

create_subnet_peers()

static void create_subnet_peers ( struct GNUNET_CONFIGURATION_Handle *  cfg, struct GNUNET_TESTING_NetjailTopology *  topology, struct GNUNET_TESTING_NetjailSubnet *  subnet  )

static

Definition at line 545 of file testing_api_topology.c.

{
  struct GNUNET_HashCode hc;
  subnet->peers = GNUNET_CONTAINER_multishortmap_create (1,GNUNET_NO);
 
  for (int i = 0; i < subnet->number_peers; i++)
  {
    struct GNUNET_ShortHashCode hkey;
    struct GNUNET_TESTING_NetjailSubnetPeer *subnet_peer = GNUNET_new (struct GNUNET_TESTING_NetjailSubnetPeer);
 
    topology->total++;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Subnet peers -> Number of nodes: %u\n",
         topology->total);
    GNUNET_CRYPTO_hash (&topology->total, sizeof(topology->total), &hc);
      memcpy (&hkey,
              &hc,
              sizeof (hkey));
    GNUNET_CONTAINER_multishortmap_put (subnet->peers,
                                        &hkey,
                                        subnet_peer,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  }
}

References GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multishortmap_create(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_NO, LOG, GNUNET_TESTING_NetjailSubnet::number_peers, GNUNET_TESTING_NetjailSubnet::peers, and GNUNET_TESTING_NetjailTopology::total.

Referenced by create_subnets().

Here is the call graph for this function:

Here is the caller graph for this function:

create_subnets()

static void create_subnets ( struct GNUNET_CONFIGURATION_Handle *  cfg, struct GNUNET_TESTING_NetjailTopology *  topology, struct GNUNET_TESTING_NetjailCarrier *  carrier  )

static

Definition at line 574 of file testing_api_topology.c.

{
  struct GNUNET_HashCode hc;
  carrier->subnets = GNUNET_CONTAINER_multishortmap_create (1,GNUNET_NO);
  
  for (int i = 0; i < carrier->number_subnets; i++)
  {
    struct GNUNET_ShortHashCode hkey;
    struct GNUNET_TESTING_NetjailSubnet *subnet = GNUNET_new (struct GNUNET_TESTING_NetjailSubnet);
    char *section;
 
    topology->total++;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Subnets -> Number of nodes: %u\n",
         topology->total);
    subnet->number = topology->total;
    subnet->index = i;
    GNUNET_CRYPTO_hash (&topology->total, sizeof(topology->total), &hc);
      memcpy (&hkey,
              &hc,
              sizeof (hkey));
    GNUNET_CONTAINER_multishortmap_put (carrier->subnets,
                                        &hkey,
                                        subnet,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
    GNUNET_asprintf (&section, "CARRIER-%u-SUBNET-%u", carrier->index, i);
    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
                                                          section,
                                                          "SUBNET_PEERS",
                                                          (unsigned long long *) &subnet->number_peers))
    {
      subnet->number_peers = topology->default_subnet_peers;
    }
 
    create_subnet_peers (cfg, topology, subnet);
 
    GNUNET_free (section);
  }
}

References cfg, create_subnet_peers(), GNUNET_TESTING_NetjailTopology::default_subnet_peers, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multishortmap_create(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_TESTING_NetjailCarrier::index, GNUNET_TESTING_NetjailSubnet::index, LOG, GNUNET_TESTING_NetjailSubnet::number, GNUNET_TESTING_NetjailSubnet::number_peers, GNUNET_TESTING_NetjailCarrier::number_subnets, GNUNET_TESTING_NetjailCarrier::subnets, and GNUNET_TESTING_NetjailTopology::total.

Referenced by GNUNET_TESTING_get_topo_from_string_().

Here is the call graph for this function:

Here is the caller graph for this function:

create_peers()

static void create_peers ( struct GNUNET_CONFIGURATION_Handle *  cfg, struct GNUNET_TESTING_NetjailTopology *  topology, struct GNUNET_TESTING_NetjailCarrier *  carrier  )

static

Definition at line 618 of file testing_api_topology.c.

{
  struct GNUNET_HashCode hc;
  carrier->peers = GNUNET_CONTAINER_multishortmap_create (1,GNUNET_NO);
 
  for (int i = 0; i < carrier->number_peers; i++)
  {
    struct GNUNET_ShortHashCode hkey;
    struct GNUNET_TESTING_NetjailCarrierPeer *peer = GNUNET_new (struct GNUNET_TESTING_NetjailCarrierPeer);
 
    topology->total++;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Carrier peers -> Number of nodes: %u\n",
         topology->total);
    peer->number = topology->total;
    GNUNET_CRYPTO_hash (&topology->total, sizeof(topology->total), &hc);
      memcpy (&hkey,
              &hc,
              sizeof (hkey));
    GNUNET_CONTAINER_multishortmap_put (carrier->peers,
                                        &hkey,
                                        peer,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
    //GNUNET_asprintf (&section, "CARRIER-%u-PEER-%u", carrier->index, i);
  }
}

References GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multishortmap_create(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_NO, LOG, GNUNET_TESTING_NetjailCarrierPeer::number, GNUNET_TESTING_NetjailCarrier::number_peers, GNUNET_TESTING_NetjailCarrier::peers, and GNUNET_TESTING_NetjailTopology::total.

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 *

data

)

Parse the topology data.

Parameters

data	The topology data.

Returns

The GNUNET_TESTING_NetjailTopology

Definition at line 649 of file testing_api_topology.c.

{
  struct GNUNET_CONFIGURATION_Handle *cfg;
  struct GNUNET_TESTING_NetjailTopology *topology = GNUNET_new (struct GNUNET_TESTING_NetjailTopology);
  topology->backbone_peers = GNUNET_CONTAINER_multishortmap_create (1,GNUNET_NO);
  topology->carriers = GNUNET_CONTAINER_multishortmap_create (1,GNUNET_NO);
  struct GNUNET_HashCode hc;
 
  cfg = GNUNET_CONFIGURATION_create ();
  GNUNET_assert (NULL != topology->carriers);
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_deserialize (cfg,
                                        input,
                                        strlen (input),
                                        NULL))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to parse configuration.\n"));
    GNUNET_CONFIGURATION_destroy (cfg);
    return NULL;
  }
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
                                                          "DEFAULTS",
                                                          "SUBNETS",
                                                          &(topology->default_subnets)))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Missing default SUBNETS!\n");
    return NULL;
  }
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
                                                          "DEFAULTS",
                                                          "TESTBED_PLUGIN",
                                                          &topology->plugin))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Missing default TESTBED_PLUGIN!\n");
    return NULL;
  }
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
                                                          "DEFAULTS",
                                                          "CARRIER_PEERS",
                                                          &(topology->default_carrier_peers)))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Missing default CARRIER_PEERS!\n");
    return NULL;
  }
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
                                                          "DEFAULTS",
                                                          "SUBNET_PEERS",
                                                          &(topology->default_subnet_peers)))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Missing default SUBNET_PEERS!\n");
    return NULL;
  }
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
                                                          "BACKBONE",
                                                          "CARRIERS",
                                                          &(topology->num_carriers)))
  {
    LOG (GNUNET_ERROR_TYPE_INFO,
         "No carrier configured!\n");
    return NULL;
  }
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
                                                          "BACKBONE",
                                                          "BACKBONE_PEERS",
                                                          &(topology->num_backbone_peers)))
  {
    LOG (GNUNET_ERROR_TYPE_INFO,
         "No backbone peers configured!\n");
    return NULL;
  }
  for (int i = 0;i < topology->num_backbone_peers; i++)
  {
    struct GNUNET_TESTING_NetjailBackbonePeer *peer = GNUNET_new (struct GNUNET_TESTING_NetjailBackbonePeer);
    struct GNUNET_ShortHashCode hkey;
 
    topology->total++;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Backbone peers -> Number of nodes: %u\n",
         topology->total);
    peer->number = topology->total;
    GNUNET_CRYPTO_hash (&topology->total, sizeof(topology->total), &hc);
      memcpy (&hkey,
              &hc,
              sizeof (hkey));
    GNUNET_CONTAINER_multishortmap_put (topology->backbone_peers,
                                        &hkey,
                                        peer,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  }
  GNUNET_assert (NULL != topology->carriers);
  for (int i = 0;i < topology->num_carriers; i++)
  {
    struct GNUNET_TESTING_NetjailCarrier *carrier = GNUNET_new (struct GNUNET_TESTING_NetjailCarrier);
    struct GNUNET_ShortHashCode hkey;
    char *section;
 
    topology->total++;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Carrier -> Number of nodes: %u\n",
         topology->total);
    carrier->number = topology->total;
    GNUNET_CRYPTO_hash (&topology->total, sizeof(topology->total), &hc);
    memcpy (&hkey,
              &hc,
              sizeof (hkey));
    GNUNET_assert (NULL != topology->carriers);
    GNUNET_CONTAINER_multishortmap_put (topology->carriers,
                                        &hkey,
                                        carrier,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
    GNUNET_asprintf (&section, "CARRIER-%u", i); 
    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
                                                          section,
                                                          "SUBNETS",
                                                          (unsigned long long *) &carrier->number_subnets))
    {
      carrier->number_subnets = topology->default_subnets;
      LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Carrier -> Default number of subnets: %u\n",
         carrier->number_subnets);
    }
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Carrier -> number of subnets: %u\n",
         carrier->number_subnets);
    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
                                                          section,
                                                          "CARRIER_PEERS",
                                                          (unsigned long long *) &carrier->number_peers))
    {
      carrier->number_peers = topology->default_carrier_peers;
      LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Carrier -> Default number of peers: %u\n",
         carrier->number_peers);
    }
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Carrier -> Default number of peers: %u\n",
         carrier->number_peers);
    create_peers  (cfg, topology, carrier);
    create_subnets (cfg, topology, carrier);
 
    GNUNET_free (section);
  }
 
  GNUNET_free (cfg);
  
  return topology;
}

References _, GNUNET_TESTING_NetjailTopology::backbone_peers, GNUNET_TESTING_NetjailTopology::carriers, cfg, create_peers(), create_subnets(), GNUNET_TESTING_NetjailTopology::default_carrier_peers, GNUNET_TESTING_NetjailTopology::default_subnet_peers, GNUNET_TESTING_NetjailTopology::default_subnets, GNUNET_asprintf(), GNUNET_assert, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_deserialize(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multishortmap_create(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, LOG, GNUNET_TESTING_NetjailTopology::num_backbone_peers, GNUNET_TESTING_NetjailTopology::num_carriers, GNUNET_TESTING_NetjailBackbonePeer::number, GNUNET_TESTING_NetjailCarrier::number, GNUNET_TESTING_NetjailCarrier::number_peers, GNUNET_TESTING_NetjailCarrier::number_subnets, GNUNET_TESTING_NetjailTopology::plugin, and GNUNET_TESTING_NetjailTopology::total.

Referenced by handle_helper_init(), netjail_exec_run(), and run().

Here is the call graph for this function:

Here is the caller graph for this function: