transport_api_cmd_backchannel_check.c File Reference

#include "platform.h"
#include "gnunet_common.h"
#include "gnunet_util_lib.h"
#include "gnunet_testing_ng_lib.h"
#include "gnunet_testing_netjail_lib.h"
#include "gnunet_transport_application_service.h"
#include "transport-testing-cmds.h"

Include dependency graph for transport_api_cmd_backchannel_check.c:

Go to the source code of this file.

Data Structures
struct	CheckState
	Struct to store information needed in callbacks. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "udp-backchannel",__VA_ARGS__)
	Generic logging shortcut. More...
#define	UDP   "udp"
#define	MAX_LINE_LENGTH   1024
	Maximum length allowed for line input. More...

Functions
static void	read_from_log (void *cls)
static enum GNUNET_GenericReturnValue	will_the_other_node_connect_via_udp (struct CheckState *cs, const struct GNUNET_TESTING_NetjailNode *node)
static void	add_search_string (struct CheckState *cs, const struct GNUNET_TESTING_NetjailNode *node)
static void	backchannel_check_run (void *cls, struct GNUNET_TESTING_Interpreter *is)
	The run method of this cmd will connect to peers. More...
static int	backchannel_check_traits (void *cls, const void **ret, const char *trait, unsigned int index)
	Trait function of this cmd does nothing. More...
static void	backchannel_check_cleanup (void *cls)
	The cleanup function of this cmd frees resources the cmd allocated. More...
struct GNUNET_TESTING_Command	GNUNET_TRANSPORT_cmd_backchannel_check (const char *label, const char *start_peer_label, const char *create_label, uint32_t num, unsigned int node_n, unsigned int namespace_n, struct GNUNET_TESTING_NetjailTopology *topology)
	Create command. More...

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "udp-backchannel",__VA_ARGS__)

Generic logging shortcut.

Definition at line 37 of file transport_api_cmd_backchannel_check.c.

UDP

#define UDP   "udp"

Definition at line 39 of file transport_api_cmd_backchannel_check.c.

MAX_LINE_LENGTH

#define MAX_LINE_LENGTH   1024

Maximum length allowed for line input.

Definition at line 44 of file transport_api_cmd_backchannel_check.c.

Function Documentation

read_from_log()

static void read_from_log ( void *  cls )

static

Parameters

cls	The cmd state CheckState.

Definition at line 133 of file transport_api_cmd_backchannel_check.c.

{
  struct CheckState *cs = cls;
  char line[MAX_LINE_LENGTH + 1];
  char *search_string;
 
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "read_from_log\n");
 
  cs->fh = GNUNET_DISK_file_open ("test.out",
                                  GNUNET_DISK_OPEN_READ,
                                  GNUNET_DISK_PERM_USER_READ);
 
  cs->task = NULL;
 
  /* read message from line and handle it */
  cs->stream = fdopen (cs->fh->fd, "r");
  memset (line, 0, MAX_LINE_LENGTH + 1);
 
  // fgets (line, MAX_LINE_LENGTH, cs->stream);
  // while (NULL != line &&  0 != strcmp (line, ""))// '\0' != line[0])
  while  (NULL != fgets (line, MAX_LINE_LENGTH, cs->stream))
  {
    /*LOG (GNUNET_ERROR_TYPE_DEBUG,
         "cs->received_backchannel_msgs: %u\n",
         cs->received_backchannel_msgs);*/
    /*if (NULL == strstr (line, "line"))
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "line: %s",
           line);*/
 
 
    for (int i = 0; i < cs->con_num; i++)
    {
      search_string = cs->search_string[i];
      /*LOG (GNUNET_ERROR_TYPE_DEBUG,
           "search %u %u: %s %p\n",
           i,
           cs->con_num,
           cs->search_string[i],
           cs->search_string);
      fprintf (stderr,
      line);*/
      if (NULL != strstr (line,
                          search_string))
      // "Delivering backchannel message from 4TTC to F7B5 of type 1460 to udp"))
      // cs->search_string[i]))
      {
        cs->received_backchannel_msgs++;
        LOG (GNUNET_ERROR_TYPE_DEBUG,
             "received_backchannel_msgs %u con_num %u\n",
             cs->received_backchannel_msgs,
             cs->con_num);
        if (cs->received_backchannel_msgs == cs->con_num)
        {
          LOG (GNUNET_ERROR_TYPE_DEBUG,
               "search finished %lu %lu %u\n",
               strlen (cs->search_string[i]),
               strlen (
                 "Delivering backchannel message from 4TTC to F7B5 of type 1460 to udp"),
               strcmp (
                 "Delivering backchannel message from 4TTC to F7B5 of type 1460 to udp",
                 cs->search_string[i]));
          GNUNET_TESTING_async_finish (&cs->ac);
          fclose (cs->stream);
          return;
        }
      }
    }
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "read_from_log end\n");
  fclose (cs->stream);
  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
                                &read_from_log,
                                cs);
  /*if (NULL == fgets (line, MAX_LINE_LENGTH, cs->stream))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "read null\n");
    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                  &read_from_log,
                                  cs);
    return;
    }*/
  /*else {
    cs->task =
      GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                      cs->fh,
                                      &read_from_log,
                                      cs);
 
 
                                      }*/
}

References CheckState::ac, CheckState::con_num, GNUNET_DISK_FileHandle::fd, CheckState::fh, GNUNET_DISK_file_open(), GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_USER_READ, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_delayed(), GNUNET_TESTING_async_finish(), GNUNET_TIME_UNIT_MINUTES, line, LOG, MAX_LINE_LENGTH, read_from_log(), CheckState::received_backchannel_msgs, CheckState::search_string, CheckState::stream, and CheckState::task.

Referenced by backchannel_check_run(), and read_from_log().

Here is the call graph for this function:

Here is the caller graph for this function:

will_the_other_node_connect_via_udp()

static enum GNUNET_GenericReturnValue will_the_other_node_connect_via_udp ( struct CheckState *  cs, const struct GNUNET_TESTING_NetjailNode *  node  )

static

Definition at line 232 of file transport_api_cmd_backchannel_check.c.

{
  // struct GNUNET_TESTING_NetjailTopology *topology = cs->topology;
  // unsigned int node_n = connection->node_n;
  // unsigned int namespace_n = connection->namespace_n;
  // struct GNUNET_HashCode hc;
  // struct GNUNET_ShortHashCode *key = GNUNET_new (struct GNUNET_ShortHashCode);
  // struct GNUNET_HashCode hc_namespace;
  /*struct GNUNET_ShortHashCode *key_namespace = GNUNET_new (struct
    GNUNET_ShortHashCode);*/
  // struct GNUNET_TESTING_NetjailNode *node;
  struct GNUNET_TESTING_NodeConnection *pos_connection;
  struct GNUNET_TESTING_AddressPrefix *pos_prefix;
  // struct GNUNET_TESTING_NetjailNamespace *namespace;
  // struct GNUNET_CONTAINER_MultiShortmap *map;
 
  /* if (0 == connection->namespace_n) */
  /* { */
  /*   map = topology->map_globals; */
  /* } */
  /* else */
  /* { */
  /*   GNUNET_CRYPTO_hash (&namespace_n, sizeof(namespace_n), &hc_namespace); */
  /*   memcpy (key_namespace, */
  /*           &hc_namespace, */
  /*           sizeof (*key_namespace)); */
  /*   if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_contains ( */
  /*         topology->map_namespaces, */
  /*         key_namespace)) */
  /*   { */
  /*     namespace = GNUNET_CONTAINER_multishortmap_get (topology->map_namespaces, */
  /*                                                     key_namespace); */
  /*     map = namespace->nodes; */
  /*   } */
  /*   else */
  /*     GNUNET_assert (0); */
  /* } */
 
  /* GNUNET_CRYPTO_hash (&node_n, sizeof(node_n), &hc); */
  /* memcpy (key, */
  /*         &hc, */
  /*         sizeof (*key)); */
  /* if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_contains ( */
  /*       map, */
  /*       key)) */
  /* { */
  /*   node = GNUNET_CONTAINER_multishortmap_get (cs->topology->map_globals, */
  /*                                              key); */
  /*   for (pos_connection = node->node_connections_head; NULL != pos_connection; */
  /*        pos_connection = pos_connection->next) */
  /*   { */
  /*     if ((node->namespace_n == pos_connection->namespace_n) && */
  /*         (node->node_n == pos_connection->node_n) ) */
  /*     { */
  /*       for (pos_prefix = pos_connection->address_prefixes_head; NULL != */
  /*            pos_prefix; */
  /*            pos_prefix = */
  /*              pos_prefix->next) */
  /*       { */
  /*         if (0 == strcmp (UDP, pos_prefix->address_prefix)) */
  /*         { */
  /*           return GNUNET_YES; */
  /*         } */
  /*       } */
  /*     } */
  /*   } */
  /* } */
 
  for (pos_connection = node->node_connections_head; NULL != pos_connection;
       pos_connection = pos_connection->next)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "connect via udp %u %u %u %u\n",
                node->namespace_n,
                cs->namespace_n,
                node->node_n,
                cs->node_n);
    if ((pos_connection->namespace_n == cs->namespace_n) &&
        (pos_connection->node_n == cs->node_n) )
    {
      for (pos_prefix = pos_connection->address_prefixes_head; NULL !=
           pos_prefix;
           pos_prefix =
             pos_prefix->next)
      {
        if (0 == strcmp (UDP, pos_prefix->address_prefix))
        {
          return GNUNET_YES;
        }
      }
    }
  }
 
  return GNUNET_NO;
}

References GNUNET_TESTING_AddressPrefix::address_prefix, GNUNET_TESTING_NodeConnection::address_prefixes_head, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_YES, GNUNET_TESTING_NodeConnection::namespace_n, GNUNET_TESTING_NetjailNode::namespace_n, CheckState::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, CheckState::node_n, and UDP.

Referenced by backchannel_check_run().

Here is the caller graph for this function:

add_search_string()

static void add_search_string ( struct CheckState *  cs, const struct GNUNET_TESTING_NetjailNode *  node  )

static

Definition at line 333 of file transport_api_cmd_backchannel_check.c.

{
  unsigned int num;
  struct GNUNET_PeerIdentity *peer;
  struct GNUNET_PeerIdentity *us;
  char *buf;
  char *part_one = "Delivering backchannel message from ";
  char *part_two = " to ";
  char *part_three = " of type 1460 to udp";
  char *peer_id;
  char *us_id;
 
  if (0 == node->namespace_n)
    num = node->node_n;
  else
    num = (node->namespace_n - 1) * cs->topology->nodes_m + node->node_n
          + cs->topology->nodes_x;
 
  // num = GNUNET_TESTING_calculate_num (pos_connection, cs->topology);
  peer = GNUNET_TESTING_get_peer (num, cs->tl_system);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "peer: %s num %u\n",
       GNUNET_i2s (peer),
       num);
  us = GNUNET_TESTING_get_peer (cs->num, cs->tl_system);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "us: %s cs->num %d\n",
       GNUNET_i2s (us),
       cs->num);
 
  GNUNET_asprintf (&peer_id,
                   "%s",
                   GNUNET_i2s (peer));
  GNUNET_asprintf (&us_id,
                   "%s",
                   GNUNET_i2s (us));
 
  if (0 < GNUNET_asprintf (&buf,
                           "%s%s%s%s%s",
                           part_one,
                           us_id,
                           part_two,
                           peer_id,
                           part_three))
  {
    GNUNET_array_append (cs->search_string,
                         cs->con_num,
                         buf);
    /*LOG (GNUNET_ERROR_TYPE_DEBUG,
         "con_num: %u search: %s %p\n",
         cs->con_num,
         cs->search_string[cs->con_num - 1],
         cs->search_string);*/
  }
  else
    GNUNET_assert (0);
  GNUNET_free (peer);
  GNUNET_free (us);
}

References CheckState::con_num, GNUNET_array_append, GNUNET_asprintf(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_TESTING_get_peer(), LOG, GNUNET_TESTING_NetjailNode::namespace_n, GNUNET_TESTING_NetjailNode::node_n, GNUNET_TESTING_NetjailTopology::nodes_m, GNUNET_TESTING_NetjailTopology::nodes_x, CheckState::num, peer_id, CheckState::search_string, CheckState::tl_system, and CheckState::topology.

Referenced by backchannel_check_run().

Here is the call graph for this function:

Here is the caller graph for this function:

backchannel_check_run()

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

static

The run method of this cmd will connect to peers.

Definition at line 400 of file transport_api_cmd_backchannel_check.c.

{
  struct CheckState *cs = cls;
  const struct GNUNET_TESTING_Command *system_cmd;
  const struct GNUNET_TESTBED_System *tl_system;
  const struct GNUNET_TESTING_Command *peer1_cmd;
  const struct GNUNET_TRANSPORT_ApplicationHandle *ah;
  struct GNUNET_CONTAINER_MultiShortmapIterator *node_it;
  struct GNUNET_CONTAINER_MultiShortmapIterator *namespace_it;
  struct GNUNET_ShortHashCode node_key;
  struct GNUNET_ShortHashCode namespace_key;
  const struct GNUNET_TESTING_NetjailNode *node;
  const struct GNUNET_TESTING_NetjailNamespace *namespace;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "check run 1\n");
 
  peer1_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
                                                         cs->start_peer_label);
  GNUNET_TRANSPORT_TESTING_get_trait_application_handle (peer1_cmd,
                                                         &ah);
 
  system_cmd = GNUNET_TESTING_interpreter_lookup_command (is,
                                                          cs->create_label);
  GNUNET_TESTING_get_trait_test_system (system_cmd,
                                        &tl_system);
 
  cs->tl_system = tl_system;
 
  cs->node_connections_head = GNUNET_TESTING_get_connections (cs->num,
                                                              cs->topology);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "check run 2\n");
 
 
  node_it = GNUNET_CONTAINER_multishortmap_iterator_create (
    cs->topology->map_globals);
 
  while (GNUNET_YES == GNUNET_CONTAINER_multishortmap_iterator_next (node_it,
                                                                     &node_key,
                                                                     (const
                                                                      void**) &
                                                                     node))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "namespace_n %u node_n %u\n",
         node->namespace_n,
         node->node_n);
    if (GNUNET_YES == will_the_other_node_connect_via_udp (cs, node))
    {
      add_search_string (cs, node);
    }
  }
  GNUNET_free (node_it);
  namespace_it = GNUNET_CONTAINER_multishortmap_iterator_create (
    cs->topology->map_namespaces);
  while (GNUNET_YES == GNUNET_CONTAINER_multishortmap_iterator_next (
           namespace_it,
           &namespace_key,
           (const
            void**) &namespace))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "namespace_n %u\n",
         node->namespace_n);
    node_it = GNUNET_CONTAINER_multishortmap_iterator_create (
      namespace->nodes);
    while (GNUNET_YES == GNUNET_CONTAINER_multishortmap_iterator_next (node_it,
                                                                       &node_key
                                                                       ,
                                                                       (const
                                                                        void**)
                                                                       &node))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "namespace_n %u node_n %u\n",
           node->namespace_n,
           node->node_n);
      if (GNUNET_YES == will_the_other_node_connect_via_udp (cs, node))
      {
        add_search_string (cs, node);
      }
    }
    GNUNET_free (node_it);
  }
 
  if (0 != cs->con_num)
  {
    cs->task =
      GNUNET_SCHEDULER_add_now (&read_from_log,
                                cs);
  }
  else
    GNUNET_TESTING_async_finish (&cs->ac);
 
  GNUNET_free (namespace_it);
}

References CheckState::ac, add_search_string(), ah, CheckState::con_num, CheckState::create_label, GNUNET_CONTAINER_multishortmap_iterator_create(), GNUNET_CONTAINER_multishortmap_iterator_next(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_SCHEDULER_add_now(), GNUNET_TESTING_async_finish(), GNUNET_TESTING_get_connections(), GNUNET_TESTING_interpreter_lookup_command(), GNUNET_TRANSPORT_TESTING_get_trait_application_handle(), GNUNET_YES, is, LOG, GNUNET_TESTING_NetjailTopology::map_globals, GNUNET_TESTING_NetjailTopology::map_namespaces, GNUNET_TESTING_NetjailNode::namespace_n, CheckState::node_connections_head, GNUNET_TESTING_NetjailNode::node_n, CheckState::num, read_from_log(), CheckState::start_peer_label, CheckState::task, CheckState::tl_system, CheckState::topology, and will_the_other_node_connect_via_udp().

Referenced by GNUNET_TRANSPORT_cmd_backchannel_check().

Here is the call graph for this function:

Here is the caller graph for this function:

backchannel_check_traits()

static int backchannel_check_traits ( void *  cls, const void **  ret, const char *  trait, unsigned int  index  )

static

Trait function of this cmd does nothing.

Definition at line 506 of file transport_api_cmd_backchannel_check.c.

{
  return GNUNET_OK;
}

References GNUNET_OK.

Referenced by GNUNET_TRANSPORT_cmd_backchannel_check().

Here is the caller graph for this function:

backchannel_check_cleanup()

static void backchannel_check_cleanup ( void *  cls )

static

The cleanup function of this cmd frees resources the cmd allocated.

Definition at line 520 of file transport_api_cmd_backchannel_check.c.

{
  struct ConnectPeersState *cs = cls;
 
  GNUNET_free (cs);
}

References GNUNET_free.

Referenced by GNUNET_TRANSPORT_cmd_backchannel_check().

Here is the caller graph for this function:

GNUNET_TRANSPORT_cmd_backchannel_check()

struct GNUNET_TESTING_Command GNUNET_TRANSPORT_cmd_backchannel_check	(	const char *	label,
		const char *	start_peer_label,
		const char *	create_label,
		uint32_t	num,
		unsigned int	node_n,
		unsigned int	namespace_n,
		struct GNUNET_TESTING_NetjailTopology *	topology
	)

Create command.

Parameters

label	name for command.
start_peer_label	Label of the cmd to start a peer.
create_label	Label of the cmd to create the testing system.
num	Number globally identifying the node.
node_n	The number of the node in a network namespace.
namespace_n	The number of the network namespace.
topology	The topology for the test setup.

Returns

command.

Definition at line 529 of file transport_api_cmd_backchannel_check.c.

{
  struct CheckState *cs;
 
  cs = GNUNET_new (struct CheckState);
  cs->start_peer_label = start_peer_label;
  cs->num = num;
  cs->create_label = create_label;
  cs->topology = topology;
  cs->node_n = node_n;
  cs->namespace_n = namespace_n;
 
  return GNUNET_TESTING_command_new_ac (cs,
                                        label,
                                        &backchannel_check_run,
                                        &backchannel_check_cleanup,
                                        &backchannel_check_traits,
                                        &cs->ac);
}

References CheckState::ac, backchannel_check_cleanup(), backchannel_check_run(), backchannel_check_traits(), CheckState::create_label, GNUNET_new, GNUNET_TESTING_command_new_ac(), CheckState::namespace_n, CheckState::node_n, CheckState::num, CheckState::start_peer_label, and CheckState::topology.

Here is the call graph for this function: