testing_api_cmd_netjail_start_cmds_helper.c File Reference

Command to start the netjail peers. More...

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

Include dependency graph for testing_api_cmd_netjail_start_cmds_helper.c:

Go to the source code of this file.

Data Structures
struct	NetJailState
	Struct to hold information for callbacks. More...
struct	HelperState
struct	TestingSystemCount
	Struct containing the number of the netjail node and the NetJailState which will be handed to callbacks specific to a test environment. More...

Macros
#define	LOG(kind, ...)   GNUNET_log (kind, __VA_ARGS__)
	Generic logging shortcut. More...

Functions
static void	clear_msg (void *cls, enum GNUNET_GenericReturnValue result)
	Continuation function from GNUNET_HELPER_send() More...
static void	handle_helper_barrier_reached (void *cls, const struct GNUNET_TESTING_CommandBarrierReached *rm)
static void	handle_helper_local_finished (void *cls, const struct GNUNET_TESTING_CommandLocalFinished *lf)
static enum GNUNET_GenericReturnValue	helper_mst (void *cls, const struct GNUNET_MessageHeader *message)
	Functions with this signature are called whenever a complete message is received by the tokenizer. More...
static void	exp_cb (void *cls)
	Callback called if there was an exception during execution of the helper. More...
static enum GNUNET_GenericReturnValue	add_barrier (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
static bool	send_start_messages (struct NetJailState *ns, struct GNUNET_HELPER_Handle *helper)
static bool	start_helper (struct NetJailState *ns, unsigned int script_num)
	Function which start a single helper process. More...
static void	do_timeout (void *cls)
	Function run when the cmd terminates (good or bad) with timeout. More...
static int	start_peer (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
static int	start_subnets (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
static int	start_carriers (void *cls, const struct GNUNET_ShortHashCode *key, void *value)
static void	netjail_exec_run (void *cls, struct GNUNET_TESTING_Interpreter *is)
	This function starts a helper process for each node. More...
static void	netjail_exec_cleanup (void *cls)
	Code to clean up resource this cmd used. More...
static enum GNUNET_GenericReturnValue	netjail_exec_traits (void *cls, const void **ret, const char *trait, unsigned int index)
	This function prepares an array with traits. More...
struct GNUNET_TESTING_Command	GNUNET_TESTING_cmd_netjail_start_helpers (const char *label, const char *topology_cmd_label, struct GNUNET_TIME_Relative timeout)
	Create command. More...

Variables
unsigned int	node_number
	The network namespace number of a node. More...

Detailed Description

Command to start the netjail peers.

Author

t3sserakt

Definition in file testing_api_cmd_netjail_start_cmds_helper.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log (kind, __VA_ARGS__)

Generic logging shortcut.

Definition at line 37 of file testing_api_cmd_netjail_start_cmds_helper.c.

Function Documentation

clear_msg()

static void clear_msg ( void *  cls, enum GNUNET_GenericReturnValue  result  )

static

Continuation function from GNUNET_HELPER_send()

Parameters

cls	closure
result	GNUNET_OK on success, GNUNET_NO if helper process died GNUNET_SYSERR during GNUNET_HELPER_stop

Definition at line 178 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct TestingSystemCount *tbc = cls;
  struct NetJailState *ns = tbc->ns;
 
  GNUNET_assert (NULL != tbc->shandle);
  tbc->shandle = NULL;
  GNUNET_CONTAINER_DLL_remove (ns->tbc_head,
                               ns->tbc_tail,
                               tbc);
  GNUNET_free (tbc);
  if ( (! ns->failed) &&
       (GNUNET_OK != result) )
  {
    ns->failed = true;
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed sending message to helper!\n");
    GNUNET_TESTING_FAIL (ns->is);
  }
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_TESTING_FAIL, ns, TestingSystemCount::ns, result, and TestingSystemCount::shandle.

Referenced by send_start_messages().

Here is the caller graph for this function:

handle_helper_barrier_reached()

static void handle_helper_barrier_reached ( void *  cls, const struct GNUNET_TESTING_CommandBarrierReached *  rm  )

static

Definition at line 202 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct HelperState *hs = cls;
  struct NetJailState *ns = hs->ns;
  struct GNUNET_TESTING_Barrier *barrier;
 
  barrier = GNUNET_TESTING_get_barrier2_ (ns->is,
                                          &rm->barrier_key);
  if (NULL == barrier)
  {
    if (! ns->failed)
    {
      ns->failed = true;
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "We did not found the barrier that was supposedly reached.!\n");
      GNUNET_TESTING_async_fail (&ns->ac); 
    }
    return;
  }
  if (barrier->inherited)
  {
    /* pass on to parent */
    GNUNET_TESTING_loop_notify_parent_ (ns->is,
                                        &rm->header);
  }
  else
  {
    barrier->reached++;
    if (barrier->reached == barrier->expected_reaches)
    {
      struct GNUNET_TESTING_CommandBarrierSatisfied cbs = {
        .header.size
          = htons (sizeof (cbs)),
        .header.type
          = htons (GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_CROSSABLE),
        .barrier_key
          = rm->barrier_key
      };
 
      GNUNET_assert (! barrier->satisfied);
      barrier->satisfied = true;
      /* unblock children */
      GNUNET_TESTING_loop_notify_children_ (ns->is,
                                            &cbs.header);
      /* unblock self */
      for (unsigned int i = 0; i<barrier->cnt_waiting; i++)
        GNUNET_TESTING_async_finish (barrier->waiting[i]);
      GNUNET_array_grow (barrier->waiting,
                         barrier->cnt_waiting,
                         0);
    }
  }
}

References GNUNET_TESTING_CommandBarrierReached::barrier_key, GNUNET_TESTING_Barrier::cnt_waiting, GNUNET_TESTING_Barrier::expected_reaches, GNUNET_array_grow, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_CROSSABLE, GNUNET_TESTING_async_fail(), GNUNET_TESTING_async_finish(), GNUNET_TESTING_get_barrier2_(), GNUNET_TESTING_loop_notify_children_(), GNUNET_TESTING_loop_notify_parent_(), GNUNET_TESTING_CommandBarrierReached::header, GNUNET_TESTING_CommandBarrierSatisfied::header, GNUNET_TESTING_Barrier::inherited, ns, HelperState::ns, GNUNET_TESTING_Barrier::reached, GNUNET_TESTING_Barrier::satisfied, GNUNET_MessageHeader::size, and GNUNET_TESTING_Barrier::waiting.

Here is the call graph for this function:

handle_helper_local_finished()

static void handle_helper_local_finished ( void *  cls, const struct GNUNET_TESTING_CommandLocalFinished *  lf  )

static

Definition at line 260 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct HelperState *hs = cls;
  struct NetJailState *ns = hs->ns;
 
  GNUNET_HELPER_stop (hs->helper, GNUNET_YES);
  hs->finished = GNUNET_YES;
  ns->n_finished++;
  if ( (! ns->failed) &&
       (GNUNET_OK != ntohl (lf->rv)) )
  {
    ns->failed = true;
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Helper finished with error!\n");
    GNUNET_TESTING_async_fail (&ns->ac);
    return;
  }
  if (ns->n_finished == ns->n_helpers)
  {
    GNUNET_SCHEDULER_cancel (ns->timeout_task);
    ns->timeout_task = NULL;
    GNUNET_TESTING_async_finish (&ns->ac);
  }
}

References HelperState::finished, GNUNET_ERROR_TYPE_ERROR, GNUNET_HELPER_stop(), GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_TESTING_async_fail(), GNUNET_TESTING_async_finish(), GNUNET_YES, HelperState::helper, lf(), ns, and HelperState::ns.

Here is the call graph for this function:

helper_mst()

static enum GNUNET_GenericReturnValue helper_mst ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

Functions with this signature are called whenever a complete message is received by the tokenizer.

Do not call GNUNET_SERVER_mst_destroy in callback

Parameters

cls	closure
message	the actual message

Returns

GNUNET_OK on success, GNUNET_SYSERR to stop further processing

Definition at line 299 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct HelperState *hs = cls;
  struct NetJailState *ns = hs->ns;
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_fixed_size (
      helper_barrier_reached,
      GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_REACHED,
      struct GNUNET_TESTING_CommandBarrierReached,
      hs),
    GNUNET_MQ_hd_fixed_size (
      helper_local_finished,
      GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_FINISHED,
      struct GNUNET_TESTING_CommandLocalFinished,
      hs),
    GNUNET_MQ_handler_end ()
  };
  enum GNUNET_GenericReturnValue ret;
 
  ret = GNUNET_MQ_handle_message (handlers,
                                  message);
  if (GNUNET_OK != ret)
  {
    GNUNET_break (0);
    if (! ns->failed)
    {
      ns->failed = true;
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "We got an unknown message from the helper process!\n");
      GNUNET_TESTING_async_fail (&ns->ac);
    }
  }
  return ret;
}

References GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MESSAGE_TYPE_CMDS_HELPER_BARRIER_REACHED, GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_FINISHED, GNUNET_MQ_handle_message(), GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_OK, GNUNET_TESTING_async_fail(), handlers, ns, HelperState::ns, and ret.

Referenced by start_helper().

Here is the call graph for this function:

Here is the caller graph for this function:

exp_cb()

static void exp_cb ( void *  cls )

static

Callback called if there was an exception during execution of the helper.

Definition at line 340 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct HelperState *hs = cls;
  struct NetJailState *ns = hs->ns;
 
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
              "Called exp_cb.\n");
  if (NULL != ns->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (ns->timeout_task);
    ns->timeout_task = NULL;
  }
  if (! ns->failed)
    GNUNET_TESTING_async_fail (&ns->ac);
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_cancel(), GNUNET_TESTING_async_fail(), ns, and HelperState::ns.

Referenced by GNUNET_HELPER_start(), and start_helper().

Here is the call graph for this function:

Here is the caller graph for this function:

add_barrier()

static enum GNUNET_GenericReturnValue add_barrier ( void *  cls, const struct GNUNET_ShortHashCode *  key, void *  value  )

static

Definition at line 358 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct GNUNET_ShortHashCode **bar_posp = cls;
  struct GNUNET_ShortHashCode *bar_pos = *bar_posp;
 
  *bar_pos = *key;
  *bar_posp = bar_pos + 1;
  return GNUNET_OK;
}

References GNUNET_OK, and key.

Referenced by send_start_messages().

Here is the caller graph for this function:

send_start_messages()

static bool send_start_messages ( struct NetJailState *  ns, struct GNUNET_HELPER_Handle *  helper  )

static

Returns

true on success

Definition at line 375 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct GNUNET_TESTING_CommandHelperInit *msg;
  struct TestingSystemCount *tbc;
  struct GNUNET_ShortHashCode *bar;
  struct GNUNET_ShortHashCode *bar_pos;
  unsigned int num_barriers = GNUNET_TESTING_barrier_count_ (ns->is);
  size_t topo_length;
  size_t msg_len;
 
  topo_length = strlen (ns->topology_data) + 1;
  GNUNET_assert (topo_length < SIZE_MAX - sizeof (*msg));
  GNUNET_assert (SIZE_MAX / sizeof (struct GNUNET_ShortHashCode) >
                 num_barriers);
  GNUNET_assert (sizeof (*msg) + topo_length <
                 SIZE_MAX
                 - num_barriers * sizeof (struct GNUNET_ShortHashCode));
  msg_len = sizeof (*msg) + topo_length
            + num_barriers * sizeof (struct GNUNET_ShortHashCode);
  if (msg_len > UINT16_MAX)
  {
    /* ask a wizard to enhance the protocol;
       start with gzip topology_data? multiple
       init messages for barriers + topo data,
       etc.*/
    GNUNET_break (0);
    return false;
  }
  msg = GNUNET_malloc (msg_len);
  msg->header.size = htons ((uint16_t) msg_len);
  msg->header.type = htons (GNUNET_MESSAGE_TYPE_CMDS_HELPER_INIT);
  msg->barrier_count = htonl (num_barriers);
  bar = (struct GNUNET_ShortHashCode *) &msg[1];
  bar_pos = bar;
  GNUNET_TESTING_barrier_iterate_ (ns->is,
                                   &add_barrier,
                                   &bar_pos);
  GNUNET_assert (bar_pos == &bar[num_barriers]);
  memcpy (&bar[num_barriers],
          ns->topology_data,
          topo_length);
  tbc = GNUNET_new (struct TestingSystemCount);
  tbc->ns = ns;
  tbc->shandle = GNUNET_HELPER_send (
    helper,
    &msg->header,
    GNUNET_NO,
    &clear_msg,
    tbc);
  GNUNET_free (msg);
  if (NULL == tbc->shandle)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Send handle is NULL!\n");
    GNUNET_free (tbc);
    return false;
  }
  GNUNET_CONTAINER_DLL_insert (ns->tbc_head,
                               ns->tbc_tail,
                               tbc);
  return true;
}

References add_barrier(), clear_msg(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_HELPER_send(), GNUNET_log, GNUNET_malloc, GNUNET_MESSAGE_TYPE_CMDS_HELPER_INIT, GNUNET_new, GNUNET_NO, GNUNET_TESTING_barrier_count_(), GNUNET_TESTING_barrier_iterate_(), msg, ns, TestingSystemCount::ns, TestingSystemCount::shandle, GNUNET_MessageHeader::size, SIZE_MAX, and GNUNET_MessageHeader::type.

Referenced by start_helper().

Here is the call graph for this function:

Here is the caller graph for this function:

start_helper()

static bool start_helper ( struct NetJailState *  ns, unsigned int  script_num  )

static

Function which start a single helper process.

Returns

true on success

Definition at line 445 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  char *gnunet_cmds_helper
    = GNUNET_OS_get_libexec_binary_path (HELPER_CMDS_BINARY);
  char node_id[32];
  char *data_dir;
  char *script_name;
  struct GNUNET_HELPER_Handle *helper;
  struct HelperState *hs = GNUNET_new (struct HelperState);
 
  data_dir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_DATADIR);
  GNUNET_asprintf (&script_name,
                   "%s%s",
                   data_dir,
                   NETJAIL_EXEC_SCRIPT);
  GNUNET_snprintf (node_id,
                   sizeof (node_id),
                   "if%06x-%06x\n",
                   (unsigned int) getpid (),
                   script_num);
  {
    char *const script_argv[] = {
      script_name,
      node_id,
      gnunet_cmds_helper,
      node_id,
      NULL
    };
    hs->ns = ns;
    helper = GNUNET_HELPER_start (
                                  GNUNET_YES,                             /* with control pipe */
                                  script_argv[0],
                                  script_argv,
                                  &helper_mst,
                                  &exp_cb,
                                  hs);
    hs->helper = helper;
  }
  GNUNET_free (gnunet_cmds_helper);
  if (NULL == helper)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Starting helper failed. Is NULL.\n");
    GNUNET_break (0);
    GNUNET_free (hs);
    return false;
  }
  GNUNET_array_append (ns->helpers,
                       ns->n_helpers,
                       hs);
  GNUNET_TESTING_add_netjail_helper_ (ns->is,
                                      helper);
  GNUNET_free (data_dir);
  GNUNET_free (script_name);
  return send_start_messages (ns,
                              helper);
}

References exp_cb(), GNUNET_array_append, GNUNET_asprintf(), GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_HELPER_start(), GNUNET_log, GNUNET_new, GNUNET_OS_get_libexec_binary_path(), GNUNET_OS_installation_get_path(), GNUNET_OS_IPK_DATADIR, GNUNET_snprintf(), GNUNET_TESTING_add_netjail_helper_(), GNUNET_YES, HelperState::helper, HELPER_CMDS_BINARY, helper_mst(), NETJAIL_EXEC_SCRIPT, ns, HelperState::ns, and send_start_messages().

Referenced by start_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

do_timeout()

static void do_timeout ( void *  cls )

static

Function run when the cmd terminates (good or bad) with timeout.

Parameters

cls	the interpreter state

Definition at line 511 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct NetJailState *ns = cls;
 
  ns->timeout_task = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
              "Terminating cmd due to global timeout\n");
  GNUNET_TESTING_async_finish (&ns->ac);
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_TESTING_async_finish(), and ns.

Referenced by netjail_exec_run().

Here is the call graph for this function:

Here is the caller graph for this function:

start_peer()

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

static

Definition at line 523 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct NetJailState *ns = cls;
 
  if (! start_helper (ns, node_number))
  {
    return GNUNET_SYSERR;
  }
  node_number++;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Peer helper %u started.\n",
              node_number);
  return GNUNET_OK;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, node_number, ns, and start_helper().

Referenced by netjail_exec_run(), start_carriers(), and start_subnets().

Here is the call graph for this function:

Here is the caller graph for this function:

start_subnets()

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

static

Definition at line 543 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct NetJailState *ns = cls;
  struct GNUNET_TESTING_NetjailSubnet *subnet = value;
 
  node_number++;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting subnet %u.\n",
              node_number);
  if (GNUNET_SYSERR == GNUNET_CONTAINER_multishortmap_iterate (subnet->peers,
                                                           &start_peer,
                                                           ns))
    return GNUNET_SYSERR;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Subnet started.\n");
  return GNUNET_OK;
}

References GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, node_number, ns, GNUNET_TESTING_NetjailSubnet::peers, start_peer(), and value.

Referenced by start_carriers().

Here is the call graph for this function:

Here is the caller graph for this function:

start_carriers()

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

static

Definition at line 565 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct NetJailState *ns = cls;
  struct GNUNET_TESTING_NetjailCarrier *carrier = value;
 
  node_number++;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting carrier %u.\n",
              node_number);
  if (GNUNET_SYSERR == GNUNET_CONTAINER_multishortmap_iterate (carrier->peers,
                                                           &start_peer,
                                                           ns))
    return GNUNET_SYSERR;
  if (GNUNET_SYSERR == GNUNET_CONTAINER_multishortmap_iterate (carrier->subnets,
                                                           &start_subnets,
                                                           ns))
    return GNUNET_SYSERR;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Carrier started.\n");
  return GNUNET_OK;
}

References GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, node_number, ns, GNUNET_TESTING_NetjailCarrier::peers, start_peer(), start_subnets(), GNUNET_TESTING_NetjailCarrier::subnets, and value.

Referenced by netjail_exec_run().

Here is the call graph for this function:

Here is the caller graph for this function:

netjail_exec_run()

static void netjail_exec_run ( void *  cls, struct GNUNET_TESTING_Interpreter *  is  )

static

This function starts a helper process for each node.

Parameters

cls	closure.
cmd	CMD being run.
is	interpreter state.

Definition at line 599 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct NetJailState *ns = cls;
  struct GNUNET_TESTING_NetjailTopology *topology;
  bool failed = false;
  const struct GNUNET_TESTING_Command *topo_cmd;
 
  ns->is = is;
  topo_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
                                                        ns->topology_cmd_label);
  if (NULL == topo_cmd)
    GNUNET_TESTING_FAIL (is);
  if (GNUNET_OK !=
      GNUNET_TESTING_get_trait_topology_string (topo_cmd,
                                                &ns->topology_data))
    GNUNET_TESTING_FAIL (is);
  topology
    = GNUNET_TESTING_get_topo_from_string_ (ns->topology_data);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Number of nodes: %u\n",
       topology->total);
  if (GNUNET_SYSERR == GNUNET_CONTAINER_multishortmap_iterate (topology->backbone_peers,
                                                           &start_peer,
                                                           ns))
    failed = true;
  if (true == failed || GNUNET_SYSERR == GNUNET_CONTAINER_multishortmap_iterate (topology->carriers,
                                                                             &start_carriers,
                                                                             ns))
    failed = true;
  
  GNUNET_TESTING_free_topology (topology);
  if (failed)
  {
    ns->failed = true;
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to start helpers!\n");
    GNUNET_TESTING_FAIL (is);
  }
  else
    ns->timeout_task
      = GNUNET_SCHEDULER_add_delayed (ns->timeout,
                                    &do_timeout,
                                    ns);
}

References GNUNET_TESTING_NetjailTopology::backbone_peers, GNUNET_TESTING_NetjailTopology::carriers, do_timeout(), GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SYSERR, GNUNET_TESTING_FAIL, GNUNET_TESTING_free_topology(), GNUNET_TESTING_get_topo_from_string_(), GNUNET_TESTING_interpreter_lookup_command(), is, LOG, ns, start_carriers(), start_peer(), and GNUNET_TESTING_NetjailTopology::total.

Referenced by GNUNET_TESTING_cmd_netjail_start_helpers().

Here is the call graph for this function:

Here is the caller graph for this function:

netjail_exec_cleanup()

static void netjail_exec_cleanup ( void *  cls )

static

Code to clean up resource this cmd used.

Parameters

cls

closure

Definition at line 652 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct NetJailState *ns = cls;
 
  if (NULL != ns->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (ns->timeout_task);
    ns->timeout_task = NULL;
  }
  for (unsigned int i = 0; i<ns->n_helpers; i++)
  {
    if (GNUNET_NO == ns->helpers[i]->finished)
      GNUNET_HELPER_stop (ns->helpers[i]->helper,
                          GNUNET_YES);
    GNUNET_free (ns->helpers[i]);
  }
  GNUNET_free (ns);
}

References GNUNET_free, GNUNET_HELPER_stop(), GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_YES, and ns.

Referenced by GNUNET_TESTING_cmd_netjail_start_helpers().

Here is the call graph for this function:

Here is the caller graph for this function:

netjail_exec_traits()

static enum GNUNET_GenericReturnValue netjail_exec_traits ( void *  cls, const void **  ret, const char *  trait, unsigned int  index  )

static

This function prepares an array with traits.

Definition at line 676 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct NetJailState *ns = cls;
  struct GNUNET_TESTING_Trait traits[] = {
    GNUNET_TESTING_trait_end ()
  };
 
  (void) ns;
  return GNUNET_TESTING_get_trait (traits,
                                   ret,
                                   trait,
                                   index);
}

References GNUNET_TESTING_get_trait(), GNUNET_TESTING_trait_end(), GNUNET_TESTING_Trait::index, ns, ret, and traits().

Referenced by GNUNET_TESTING_cmd_netjail_start_helpers().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_TESTING_cmd_netjail_start_helpers()

struct GNUNET_TESTING_Command GNUNET_TESTING_cmd_netjail_start_helpers	(	const char *	label,
		const char *	topology_cmd_label,
		struct GNUNET_TIME_Relative	timeout
	)

Create command.

Parameters

label	Name for the command.
topology_data	topology data
timeout	Before this timeout is reached this cmd MUST finish.

Returns

command.

Definition at line 703 of file testing_api_cmd_netjail_start_cmds_helper.c.

{
  struct NetJailState *ns;
 
  ns = GNUNET_new (struct NetJailState);
  ns->topology_cmd_label = topology_cmd_label;
  ns->timeout = timeout;
  return GNUNET_TESTING_command_new_ac (ns,
                                        label,
                                        &netjail_exec_run,
                                        &netjail_exec_cleanup,
                                        &netjail_exec_traits,
                                        &ns->ac);
}

References GNUNET_new, GNUNET_TESTING_command_new_ac(), netjail_exec_cleanup(), netjail_exec_run(), netjail_exec_traits(), ns, timeout, and NetJailState::topology_cmd_label.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

node_number

unsigned int node_number

The network namespace number of a node.

Definition at line 166 of file testing_api_cmd_netjail_start_cmds_helper.c.

Referenced by start_carriers(), start_peer(), and start_subnets().