Regex profiler for testing distributed regex use. More...

#include "platform.h"
#include "gnunet_applications.h"
#include "gnunet_util_lib.h"
#include "regex_internal_lib.h"
#include "gnunet_arm_service.h"
#include "gnunet_dht_service.h"
#include "gnunet_testbed_service.h"

Include dependency graph for gnunet-regex-profiler.c:

Data Structures
struct	DLLOperation
	DLL of operations. More...

struct	RegexPeer
	Peer handles. More...

Macros
#define	FIND_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 90)

Enumerations
enum	State { STATE_INIT = 0 , STATE_SLAVES_STARTING , STATE_PEERS_CREATING , STATE_PEERS_STARTING , STATE_PEERS_LINKING , STATE_SEARCH_REGEX , STATE_PEERS_DESTROYING }
	Available states during profiling. More...

Functions
static void	dht_connect_cb (void cls, struct GNUNET_TESTBED_Operation op, void ca_result, const char emsg)
	DHT connect callback. More...

static void *	dht_ca (void cls, const struct GNUNET_CONFIGURATION_Handle cfg)
	DHT connect adapter. More...

static void	dht_da (void cls, void op_result)
	Adapter function called to destroy a connection to the DHT service. More...

static void	stats_connect_cb (void cls, struct GNUNET_TESTBED_Operation op, void ca_result, const char emsg)
	Function called by testbed once we are connected to stats service. More...

static void	announce_next_regex (void *cls)
	Start announcing the next regex in the DHT. More...

static void	do_shutdown (void *cls)
	Shutdown nicely. More...

static void	do_abort (void *cls)
	abort task to run on test timed out More...

static void *	stats_ca (void cls, const struct GNUNET_CONFIGURATION_Handle cfg)
	Adapter function called to establish a connection to statistics service. More...

static void	stats_da (void cls, void op_result)
	Adapter function called to destroy a connection to statistics service. More...

static int	stats_iterator (void cls, const char subsystem, const char *name, uint64_t value, int is_persistent)
	Process statistic values. More...

static void	stats_cb (void *cls, int success)
	Stats callback. More...

static void	do_collect_stats (void *cls)
	Task to collect all statistics from all peers, will shutdown the profiler, when done. More...

static void	find_string (void *cls)
	Start searching for the next string in the DHT. More...

static void	regex_found_handler (void cls, const struct GNUNET_PeerIdentity id, const struct GNUNET_DHT_PathElement get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement put_path, unsigned int put_path_length)
	Method called when we've found a peer that announced a regex that matches our search string. More...

static void	search_timed_out (void *cls)
	Connect by string timeout task. More...

static void	find_timed_out (void *cls)
	Search timed out. More...

static void	daemon_started (void cls, struct GNUNET_TESTBED_Operation op, const char *emsg)
	Callback called when testbed has started the daemon we asked for. More...

static void	do_announce (void *cls)
	Task to start the daemons on each peer so that the regexes are announced into the DHT. More...

static void	test_master (void cls, struct GNUNET_TESTBED_RunHandle h, unsigned int num_peers_, struct GNUNET_TESTBED_Peer **testbed_peers, unsigned int links_succeeded, unsigned int links_failed)
	Signature of a main function for a testcase. More...

static void	master_controller_cb (void cls, const struct GNUNET_TESTBED_EventInformation event)
	Function that will be called whenever something in the testbed changes. More...

static int	count_and_separate_strings (char *data, uint64_t data_size, unsigned int str_max)
	Process the text buffer counting the non-empty lines and separating them with NULL characters, for later ease of copy using (as)printf. More...

static int	create_string_array (char data, uint64_t data_size, char **strings, unsigned int str_cnt)
	Allocate a string array and fill it with the prefixed strings from a pre-processed, NULL-separated memory region. More...

static int	load_search_strings (const char filename, char **strings, unsigned int limit)
	Load search strings from given filename. More...

static void	run (void cls, char const args, const char cfgfile, const struct GNUNET_CONFIGURATION_Handle *config)
	Main function that will be run by the scheduler. More...

int	main (int argc, char const argv)
	Main function. More...

Variables
static int	in_shutdown
	Set when shutting down to avoid making more queries. More...

static struct RegexPeer *	peers
	The array of peers; we fill this as the peers are given to us by the testbed. More...

static struct GNUNET_TESTBED_HostRegistrationHandle *	reg_handle
	Host registration handle. More...

static struct GNUNET_TESTBED_ControllerProc *	mc_proc
	Handle to the master controller process. More...

static struct GNUNET_TESTBED_Controller *	mc
	Handle to the master controller. More...

static struct GNUNET_CONFIGURATION_Handle *	cfg
	Handle to global configuration. More...

static struct GNUNET_SCHEDULER_Task *	abort_task
	Abort task identifier. More...

static struct GNUNET_SCHEDULER_Task *	register_hosts_task
	Host registration task identifier. More...

static uint64_t	event_mask
	Global event mask for all testbed events. More...

static struct GNUNET_TIME_Absolute	prof_start_time
	The starting time of a profiling step. More...

static struct GNUNET_TIME_Relative	prof_time
	Duration profiling step has taken. More...

static unsigned int	num_peers
	Number of peers to be started by the profiler. More...

static int	result
	Global testing status. More...

enum State	state
	current state of profiling More...

static char *	policy_dir
	Folder where policy files are stored. More...

static char *	hosts_file
	File with hostnames where to execute the test. More...

static char *	strings_file
	File with the strings to look for. More...

static char **	search_strings
	Search strings (num_peers of them). More...

static long long unsigned int	init_parallel_searches
	How many searches are we going to start in parallel. More...

static unsigned int	parallel_searches
	How many searches are running in parallel. More...

static unsigned int	strings_found
	Number of strings found in the published regexes. More...

static unsigned int	next_search
	Index of peer to start next announce/search. More...

static struct GNUNET_SCHEDULER_Task *	search_timeout_task
	Search timeout task identifier. More...

static struct GNUNET_TIME_Relative	search_timeout_time = { 60000 }
	Search timeout in seconds. More...

static struct GNUNET_DISK_FileHandle *	data_file
	File to log statistics to. More...

static char *	data_filename
	Filename to log statistics to. More...

static char *	regex_prefix
	Prefix used for regex announcing. More...

static struct GNUNET_TIME_Relative	reannounce_period_max
	What's the maximum regex reannounce period. More...

Detailed Description

Regex profiler for testing distributed regex use.

Author: Bartlomiej Polot; Maximilian Szengel

Definition in file gnunet-regex-profiler.c.

Macro Definition Documentation

◆ FIND_TIMEOUT

#define FIND_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 90)

Definition at line 35 of file gnunet-regex-profiler.c.

Enumeration Type Documentation

◆ State

enum State

Available states during profiling.

Enumerator
STATE_INIT	Initial state.
STATE_SLAVES_STARTING	Starting slaves.
STATE_PEERS_CREATING	Creating peers.
STATE_PEERS_STARTING	Starting peers.
STATE_PEERS_LINKING	Linking peers.
STATE_SEARCH_REGEX	Matching strings against announced regexes.
STATE_PEERS_DESTROYING	Destroying peers; we can do this as the controller takes care of stopping a peer if it is running.

Definition at line 68 of file gnunet-regex-profiler.c.

{
  STATE_INIT = 0,
 
  STATE_SLAVES_STARTING,
 
  STATE_PEERS_CREATING,
 
  STATE_PEERS_STARTING,
 
  STATE_PEERS_LINKING,
 
  STATE_SEARCH_REGEX,
 
  STATE_PEERS_DESTROYING
};

Function Documentation

◆ dht_connect_cb()

static void dht_connect_cb	(	void *	cls,
		struct GNUNET_TESTBED_Operation *	op,
		void *	ca_result,
		const char *	emsg
	)

static

DHT connect callback.

Called when we are connected to the dht service for the peer in 'cls'. If successful we connect to the stats service of this peer and then try to match the search string of this peer.

Parameters

cls	internal peer id.
op	operation handle.
ca_result	connect adapter result.
emsg	error message.

Definition at line 1028 of file gnunet-regex-profiler.c.

{
  struct RegexPeer *peer = (struct RegexPeer *) cls;
 
  if ((NULL != emsg) || (NULL == op) || (NULL == ca_result))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "DHT connect failed: %s\n", emsg);
    GNUNET_assert (0);
  }
 
  GNUNET_assert (NULL != peer->dht_handle);
  GNUNET_assert (peer->op_handle == op);
  GNUNET_assert (peer->dht_handle == ca_result);
 
  peer->search_str_matched = GNUNET_NO;
  peer->search_handle = REGEX_INTERNAL_search (peer->dht_handle,
                                               peer->search_str,
                                               &regex_found_handler, peer,
                                               NULL);
  peer->prof_start_time = GNUNET_TIME_absolute_get ();
}

References RegexPeer::dht_handle, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NO, GNUNET_TIME_absolute_get(), op, RegexPeer::op_handle, RegexPeer::prof_start_time, regex_found_handler(), REGEX_INTERNAL_search(), RegexPeer::search_handle, RegexPeer::search_str, and RegexPeer::search_str_matched.

Referenced by find_string().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dht_ca()

static void * dht_ca	(	void *	cls,
		const struct GNUNET_CONFIGURATION_Handle *	cfg
	)

static

DHT connect adapter.

Opens a connection to the DHT service.

Parameters

cls	Closure (peer).
cfg	Configuration handle.

Returns

Definition at line 1055 of file gnunet-regex-profiler.c.

{
  struct RegexPeer *peer = cls;
 
  peer->dht_handle = GNUNET_DHT_connect (cfg, 32);
 
  return peer->dht_handle;
}

References cfg, RegexPeer::dht_handle, and GNUNET_DHT_connect().

Referenced by find_string().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dht_da()

static void dht_da	(	void *	cls,
		void *	op_result
	)

static

Adapter function called to destroy a connection to the DHT service.

Parameters

cls	Closure
op_result	Service handle returned from the connect adapter.

Definition at line 1066 of file gnunet-regex-profiler.c.

{
  struct RegexPeer *peer = (struct RegexPeer *) cls;
 
  GNUNET_assert (peer->dht_handle == op_result);
 
  if (NULL != peer->search_handle)
  {
    REGEX_INTERNAL_search_cancel (peer->search_handle);
    peer->search_handle = NULL;
  }
 
  if (NULL != peer->dht_handle)
  {
    GNUNET_DHT_disconnect (peer->dht_handle);
    peer->dht_handle = NULL;
  }
}

References RegexPeer::dht_handle, GNUNET_assert, GNUNET_DHT_disconnect(), op_result(), REGEX_INTERNAL_search_cancel(), and RegexPeer::search_handle.

Referenced by find_string().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stats_connect_cb()

static void stats_connect_cb	(	void *	cls,
		struct GNUNET_TESTBED_Operation *	op,
		void *	ca_result,
		const char *	emsg
	)

static

Function called by testbed once we are connected to stats service.

Get the statistics for the services of interest.

Parameters

cls	the 'struct RegexPeer' for which we connected to stats
op	connect operation handle
ca_result	handle to stats service
emsg	error message on failure

Definition at line 646 of file gnunet-regex-profiler.c.

{
  struct RegexPeer *peer = cls;
 
  if ((NULL == ca_result) || (NULL != emsg))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to connect to statistics service on peer %u: %s\n",
                peer->id, emsg);
 
    peer->stats_handle = NULL;
    return;
  }
 
  peer->stats_handle = ca_result;
 
  if (NULL == GNUNET_STATISTICS_get (peer->stats_handle, NULL, NULL,
                                     &stats_cb,
                                     &stats_iterator, peer))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Could not get statistics of peer %u!\n", peer->id);
  }
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_STATISTICS_get(), RegexPeer::id, stats_cb(), RegexPeer::stats_handle, and stats_iterator().

Referenced by do_collect_stats(), and stats_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ announce_next_regex()

static void announce_next_regex ( void * cls )

static

Start announcing the next regex in the DHT.

Parameters

cls	Index of the next peer in the peers array.
cls	Closure (unused).

Definition at line 992 of file gnunet-regex-profiler.c.

{
  struct RegexPeer *peer;
 
  if (GNUNET_YES == in_shutdown)
    return;
  if (next_search >= num_peers)
  {
    if (strings_found != num_peers)
    {
      struct GNUNET_TIME_Relative new_delay;
      if (NULL != search_timeout_task)
        GNUNET_SCHEDULER_cancel (search_timeout_task);
      new_delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15);
      search_timeout_task = GNUNET_SCHEDULER_add_delayed (new_delay,
                                                          &search_timed_out,
                                                          NULL);
    }
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Starting daemon %u\n", next_search);
  peer = &peers[next_search];
  peer->daemon_op =
    GNUNET_TESTBED_peer_manage_service (NULL,
                                        peer->peer_handle,
                                        "regexprofiler",
                                        &daemon_started,
                                        peer,
                                        1);
  next_search++;
  parallel_searches++;
}

References RegexPeer::daemon_op, daemon_started(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MINUTES, GNUNET_YES, in_shutdown, next_search, num_peers, parallel_searches, RegexPeer::peer_handle, peers, search_timed_out(), search_timeout_task, and strings_found.

Referenced by do_announce(), find_timed_out(), and regex_found_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_shutdown()

static void do_shutdown ( void * cls )

static

Shutdown nicely.

Parameters

cls NULL

Definition at line 396 of file gnunet-regex-profiler.c.

{
  struct RegexPeer *peer;
  unsigned int peer_cnt;
  unsigned int search_str_cnt;
  char output_buffer[512];
  size_t size;
 
  if (NULL != abort_task)
  {
    GNUNET_SCHEDULER_cancel (abort_task);
    abort_task = NULL;
  }
  if (NULL != register_hosts_task)
  {
    GNUNET_SCHEDULER_cancel (register_hosts_task);
    register_hosts_task = NULL;
  }
  for (peer_cnt = 0; peer_cnt < num_peers; peer_cnt++)
  {
    peer = &peers[peer_cnt];
 
    if ((GNUNET_YES != peer->search_str_matched) && (NULL != data_file) )
    {
      prof_time = GNUNET_TIME_absolute_get_duration (peer->prof_start_time);
      size =
        GNUNET_snprintf (output_buffer,
                         sizeof(output_buffer),
                         "%p Search string not found: %s (%d)\n"
                         "%p On peer: %u (%p)\n"
                         "%p After: %s\n",
                         peer, peer->search_str, peer->search_str_matched,
                         peer, peer->id, peer,
                         peer,
                         GNUNET_STRINGS_relative_time_to_string (prof_time,
                                                                 GNUNET_NO));
      if (size != GNUNET_DISK_file_write (data_file, output_buffer, size))
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
    }
 
    if (NULL != peers[peer_cnt].op_handle)
      GNUNET_TESTBED_operation_done (peers[peer_cnt].op_handle);
  }
 
  if (NULL != data_file)
  {
    GNUNET_DISK_file_close (data_file);
    data_file = NULL;
  }
  for (search_str_cnt = 0;
       search_str_cnt < num_peers && NULL != search_strings;
       search_str_cnt++)
  {
    GNUNET_free (search_strings[search_str_cnt]);
  }
  GNUNET_free (search_strings);
  search_strings = NULL;
 
  if (NULL != reg_handle)
  {
    GNUNET_TESTBED_cancel_registration (reg_handle);
    reg_handle = NULL;
  }
  if (NULL != mc)
  {
    GNUNET_TESTBED_controller_disconnect (mc);
    mc = NULL;
  }
  if (NULL != mc_proc)
  {
    GNUNET_TESTBED_controller_stop (mc_proc);
    mc_proc = NULL;
  }
  if (NULL != cfg)
  {
    GNUNET_CONFIGURATION_destroy (cfg);
    cfg = NULL;
  }
}

References abort_task, cfg, data_file, GNUNET_CONFIGURATION_destroy(), GNUNET_DISK_file_close(), GNUNET_DISK_file_write(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_snprintf(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, RegexPeer::id, mc, mc_proc, num_peers, RegexPeer::op_handle, peers, RegexPeer::prof_start_time, prof_time, reg_handle, register_hosts_task, RegexPeer::search_str, RegexPeer::search_str_matched, search_strings, and size.

Referenced by do_abort(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_abort()

static void do_abort ( void * cls )

static

abort task to run on test timed out

Parameters

cls NULL

Definition at line 483 of file gnunet-regex-profiler.c.

{
  unsigned long i = (unsigned long) cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Aborting from line %lu...\n", i);
  abort_task = NULL;
  result = GNUNET_SYSERR;
  GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
}

References abort_task, do_shutdown(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SYSERR, and result.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stats_ca()

static void * stats_ca	(	void *	cls,
		const struct GNUNET_CONFIGURATION_Handle *	cfg
	)

static

Adapter function called to establish a connection to statistics service.

Parameters

cls	closure
cfg	configuration of the peer to connect to; will be available until GNUNET_TESTBED_operation_done() is called on the operation returned from GNUNET_TESTBED_service_connect()

Returns: service handle to return in 'op_result', NULL on error

Definition at line 510 of file gnunet-regex-profiler.c.

{
  return GNUNET_STATISTICS_create ("<driver>", cfg);
}

References cfg, and GNUNET_STATISTICS_create().

Referenced by do_collect_stats(), and stats_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stats_da()

static void stats_da	(	void *	cls,
		void *	op_result
	)

static

Adapter function called to destroy a connection to statistics service.

Parameters

cls	closure
op_result	service handle returned from the connect adapter

Definition at line 525 of file gnunet-regex-profiler.c.

{
  struct RegexPeer *peer = cls;
 
  GNUNET_assert (op_result == peer->stats_handle);
 
  GNUNET_STATISTICS_destroy (peer->stats_handle, GNUNET_NO);
  peer->stats_handle = NULL;
}

References GNUNET_assert, GNUNET_NO, GNUNET_STATISTICS_destroy(), op_result(), and RegexPeer::stats_handle.

Referenced by do_collect_stats(), and stats_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stats_iterator()

static int stats_iterator	(	void *	cls,
		const char *	subsystem,
		const char *	name,
		uint64_t	value,
		int	is_persistent
	)

static

Process statistic values.

Write all values to global 'data_file', if present.

Parameters

cls	closure
subsystem	name of subsystem that created the statistic
name	the name of the datum
value	the current value
is_persistent	GNUNET_YES if the value is persistent, GNUNET_NO if not

Returns: GNUNET_OK to continue, GNUNET_SYSERR to abort iteration

Definition at line 547 of file gnunet-regex-profiler.c.

{
  struct RegexPeer *peer = cls;
  char output_buffer[512];
  size_t size;
 
  if (NULL == data_file)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "%p -> %s [%s]: %llu\n",
                peer,
                subsystem,
                name,
                (unsigned long long) value);
    return GNUNET_OK;
  }
  size =
    GNUNET_snprintf (output_buffer,
                     sizeof(output_buffer),
                     "%p [%s] %llu %s\n",
                     peer,
                     subsystem,
                     (unsigned long long) value,
                     name);
  if (size != GNUNET_DISK_file_write (data_file, output_buffer, size))
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Unable to write to file!\n");
 
  return GNUNET_OK;
}

References data_file, GNUNET_DISK_file_write(), GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_OK, GNUNET_snprintf(), name, size, subsystem, and value.

Referenced by stats_connect_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ stats_cb()

static void stats_cb	(	void *	cls,
		int	success
	)

static

Stats callback.

Finish the stats testbed operation and when all stats have been iterated, shutdown the profiler.

Parameters

cls	closure
success	GNUNET_OK if statistics were successfully obtained, GNUNET_SYSERR if not.

Definition at line 591 of file gnunet-regex-profiler.c.

{
  static unsigned int peer_cnt;
  struct RegexPeer *peer = cls;
 
  if (GNUNET_OK != success)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Getting statistics for peer %u failed!\n",
                peer->id);
    return;
  }
 
  GNUNET_assert (NULL != peer->op_handle);
 
  GNUNET_TESTBED_operation_done (peer->op_handle);
  peer->op_handle = NULL;
 
  peer_cnt++;
  peer = &peers[peer_cnt];
 
  fprintf (stderr, "s");
  if (peer_cnt == num_peers)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "\nCollecting stats finished. Shutting down.\n");
    GNUNET_SCHEDULER_shutdown ();
    result = GNUNET_OK;
  }
  else
  {
    peer->op_handle =
      GNUNET_TESTBED_service_connect (NULL,
                                      peer->peer_handle,
                                      "statistics",
                                      &stats_connect_cb,
                                      peer,
                                      &stats_ca,
                                      &stats_da,
                                      peer);
  }
}

References GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_shutdown(), RegexPeer::id, num_peers, RegexPeer::op_handle, RegexPeer::peer_handle, peers, result, stats_ca(), stats_connect_cb(), and stats_da().

Referenced by stats_connect_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_collect_stats()

static void do_collect_stats ( void * cls )

static

Task to collect all statistics from all peers, will shutdown the profiler, when done.

Parameters

cls NULL

Definition at line 682 of file gnunet-regex-profiler.c.

{
  struct RegexPeer *peer = &peers[0];
 
  GNUNET_assert (NULL != peer->peer_handle);
 
  peer->op_handle =
    GNUNET_TESTBED_service_connect (NULL,
                                    peer->peer_handle,
                                    "statistics",
                                    &stats_connect_cb,
                                    peer,
                                    &stats_ca,
                                    &stats_da,
                                    peer);
}

References GNUNET_assert, RegexPeer::op_handle, RegexPeer::peer_handle, peers, stats_ca(), stats_connect_cb(), and stats_da().

Referenced by regex_found_handler(), and search_timed_out().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_string()

static void find_string ( void * cls )

static

Start searching for the next string in the DHT.

Start searching for a string in the DHT.

Parameters

cls	Index of the next peer in the peers array.

Definition at line 881 of file gnunet-regex-profiler.c.

{
  unsigned int search_peer = (unsigned int) (long) cls;
 
  if ((search_peer >= num_peers) ||
      (GNUNET_YES == in_shutdown))
    return;
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Searching for string \"%s\" on peer %d (%u||)\n",
              peers[search_peer].search_str,
              search_peer,
              parallel_searches);
 
  peers[search_peer].op_handle =
    GNUNET_TESTBED_service_connect (NULL,
                                    peers[search_peer].peer_handle,
                                    "dht",
                                    &dht_connect_cb,
                                    &peers[search_peer],
                                    &dht_ca,
                                    &dht_da,
                                    &peers[search_peer]);
  GNUNET_assert (NULL != peers[search_peer].op_handle);
  peers[search_peer].timeout
    = GNUNET_SCHEDULER_add_delayed (FIND_TIMEOUT,
                                    &find_timed_out,
                                    &peers[search_peer]);
}

References dht_ca(), dht_connect_cb(), dht_da(), find_timed_out(), FIND_TIMEOUT, GNUNET_assert, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_YES, in_shutdown, consensus-simulation::int, num_peers, RegexPeer::op_handle, parallel_searches, RegexPeer::peer_handle, peers, RegexPeer::search_str, and RegexPeer::timeout.

Referenced by daemon_started().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ regex_found_handler()

static void regex_found_handler	(	void *	cls,
		const struct GNUNET_PeerIdentity *	id,
		const struct GNUNET_DHT_PathElement *	get_path,
		unsigned int	get_path_length,
		const struct GNUNET_DHT_PathElement *	put_path,
		unsigned int	put_path_length
	)

static

Method called when we've found a peer that announced a regex that matches our search string.

Now get the statistics.

Parameters

cls	Closure provided in REGEX_INTERNAL_search.
id	Peer providing a regex that matches the string.
get_path	Path of the get request.
get_path_length	Length of get_path.
put_path	Path of the put request.
put_path_length	Length of the put_path.

Definition at line 726 of file gnunet-regex-profiler.c.

{
  struct RegexPeer *peer = cls;
  char output_buffer[512];
  size_t size;
 
  if (GNUNET_YES == peer->search_str_matched)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "String %s on peer %u already matched!\n",
                peer->search_str, peer->id);
    return;
  }
 
  strings_found++;
  parallel_searches--;
 
  if (NULL != peer->timeout)
  {
    GNUNET_SCHEDULER_cancel (peer->timeout);
    peer->timeout = NULL;
    if (GNUNET_NO == in_shutdown)
      GNUNET_SCHEDULER_add_now (&announce_next_regex, NULL);
  }
 
  if (NULL == id)
  {
    // FIXME not possible right now
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "String matching timed out for string %s on peer %u (%i/%i)\n",
                peer->search_str, peer->id, strings_found, num_peers);
    peer->search_str_matched = GNUNET_SYSERR;
  }
  else
  {
    prof_time = GNUNET_TIME_absolute_get_duration (peer->prof_start_time);
 
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "String %s found on peer %u after %s (%i/%i) (%u||)\n",
                peer->search_str, peer->id,
                GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO),
                strings_found, num_peers, parallel_searches);
 
    peer->search_str_matched = GNUNET_YES;
 
    if (NULL != data_file)
    {
      size =
        GNUNET_snprintf (output_buffer,
                         sizeof(output_buffer),
                         "%p Peer: %u\n"
                         "%p Search string: %s\n"
                         "%p Search duration: %s\n\n",
                         peer, peer->id,
                         peer, peer->search_str,
                         peer,
                         GNUNET_STRINGS_relative_time_to_string (prof_time,
                                                                 GNUNET_NO));
 
      if (size != GNUNET_DISK_file_write (data_file, output_buffer, size))
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
    }
  }
 
  GNUNET_TESTBED_operation_done (peer->op_handle);
  peer->op_handle = NULL;
 
  if (strings_found == num_peers)
  {
    prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "All strings successfully matched in %s\n",
                GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO));
 
    if (NULL != search_timeout_task)
    {
      GNUNET_SCHEDULER_cancel (search_timeout_task);
      search_timeout_task = NULL;
    }
 
    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Collecting stats.\n");
    GNUNET_SCHEDULER_add_now (&do_collect_stats, NULL);
  }
}

References announce_next_regex(), data_file, do_collect_stats(), GNUNET_DISK_file_write(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_snprintf(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_duration(), GNUNET_YES, RegexPeer::id, in_shutdown, num_peers, RegexPeer::op_handle, parallel_searches, RegexPeer::prof_start_time, prof_start_time, prof_time, RegexPeer::search_str, RegexPeer::search_str_matched, search_timeout_task, size, strings_found, and RegexPeer::timeout.

Referenced by dht_connect_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ search_timed_out()

static void search_timed_out ( void * cls )

static

Connect by string timeout task.

This will cancel the profiler after the specified timeout 'search_timeout'.

Parameters

cls NULL

Definition at line 824 of file gnunet-regex-profiler.c.

{
  unsigned int i;
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Finding matches to all strings did not succeed after %s.\n",
              GNUNET_STRINGS_relative_time_to_string (search_timeout_time,
                                                      GNUNET_NO));
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Found %i of %i strings\n", strings_found, num_peers);
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Search timed out after %s."
              "Collecting stats and shutting down.\n",
              GNUNET_STRINGS_relative_time_to_string (search_timeout_time,
                                                      GNUNET_NO));
 
  in_shutdown = GNUNET_YES;
  for (i = 0; i < num_peers; i++)
  {
    if (NULL != peers[i].op_handle)
    {
      GNUNET_TESTBED_operation_done (peers[i].op_handle);
      peers[i].op_handle = NULL;
    }
  }
  GNUNET_SCHEDULER_add_now (&do_collect_stats, NULL);
}

References do_collect_stats(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_YES, in_shutdown, num_peers, RegexPeer::op_handle, peers, search_timeout_time, and strings_found.

Referenced by announce_next_regex(), and test_master().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_timed_out()

static void find_timed_out ( void * cls )

static

Search timed out.

It might still complete in the future, but we should start another one.

Parameters

cls	Index of the next peer in the peers array.

Definition at line 861 of file gnunet-regex-profiler.c.

{
  struct RegexPeer *p = cls;
 
  p->timeout = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Searching for string \"%s\" on peer %d timed out.\n",
              p->search_str,
              p->id);
  if (GNUNET_NO == in_shutdown)
    GNUNET_SCHEDULER_add_now (&announce_next_regex, NULL);
}

References announce_next_regex(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_now(), in_shutdown, and p.

Referenced by find_string().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ daemon_started()

static void daemon_started	(	void *	cls,
		struct GNUNET_TESTBED_Operation *	op,
		const char *	emsg
	)

static

Callback called when testbed has started the daemon we asked for.

Parameters

cls	NULL
op	the operation handle
emsg	NULL on success; otherwise an error description

Definition at line 920 of file gnunet-regex-profiler.c.

{
  struct RegexPeer *peer = (struct RegexPeer *) cls;
  unsigned long search_peer;
  unsigned int i;
 
  GNUNET_TESTBED_operation_done (peer->daemon_op);
  peer->daemon_op = NULL;
  if (NULL != emsg)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Failed to start/stop daemon at peer %u: %s\n", peer->id, emsg);
    GNUNET_assert (0);
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Daemon %u started successfully\n", peer->id);
  }
 
  /* Find a peer to look for a string matching the regex announced */
  search_peer = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
                                          num_peers);
  for (i = 0; peers[search_peer].search_str != NULL; i++)
  {
    search_peer = (search_peer + 1) % num_peers;
    if (i > num_peers)
      GNUNET_assert (0);  /* we ran out of peers, must be a bug */
  }
  peers[search_peer].search_str = search_strings[peer->id];
  peers[search_peer].search_str_matched = GNUNET_NO;
  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_saturating_multiply (
                                  reannounce_period_max,
                                  2),
                                &find_string,
                                (void *) search_peer);
}

References RegexPeer::daemon_op, find_string(), GNUNET_assert, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_relative_saturating_multiply(), RegexPeer::id, num_peers, peers, reannounce_period_max, RegexPeer::search_str, RegexPeer::search_str_matched, and search_strings.

Referenced by announce_next_regex().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_announce()

static void do_announce ( void * cls )

static

Task to start the daemons on each peer so that the regexes are announced into the DHT.

Parameters

cls NULL

Definition at line 968 of file gnunet-regex-profiler.c.

{
  unsigned int i;
 
  if (GNUNET_YES == in_shutdown)
    return;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Starting announce.\n");
  for (i = 0; i < init_parallel_searches; i++)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "  scheduling announce %u\n",
                i);
    (void) GNUNET_SCHEDULER_add_now (&announce_next_regex, NULL);
  }
}

References announce_next_regex(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_YES, in_shutdown, and init_parallel_searches.

Referenced by test_master().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ test_master()

static void test_master	(	void *	cls,
		struct GNUNET_TESTBED_RunHandle *	h,
		unsigned int	num_peers_,
		struct GNUNET_TESTBED_Peer **	testbed_peers,
		unsigned int	links_succeeded,
		unsigned int	links_failed
	)

static

Signature of a main function for a testcase.

Parameters

cls	NULL
h	the run handle
num_peers_	number of peers in 'peers'
testbed_peers	handle to peers run in the testbed. NULL upon timeout (see GNUNET_TESTBED_test_run()).
links_succeeded	the number of overlay link connection attempts that succeeded
links_failed	the number of overlay link connection attempts that failed

Definition at line 1100 of file gnunet-regex-profiler.c.

{
  unsigned int i;
 
  GNUNET_assert (num_peers_ == num_peers);
 
  prof_time = GNUNET_TIME_absolute_get_duration (prof_start_time);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Testbed started in %s\n",
              GNUNET_STRINGS_relative_time_to_string (prof_time, GNUNET_NO));
 
  if (NULL != abort_task)
  {
    GNUNET_SCHEDULER_cancel (abort_task);
    abort_task = NULL;
  }
 
  for (i = 0; i < num_peers; i++)
  {
    peers[i].peer_handle = testbed_peers[i];
  }
  if (GNUNET_NO ==
      GNUNET_CONFIGURATION_get_value_yesno (cfg, "DHT", "DISABLE_TRY_CONNECT"))
  {
    struct GNUNET_TIME_Relative settle_time;
 
    settle_time =
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
                                     10 * num_peers);
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Waiting for DHT for %s to settle new connections.\n\n",
                GNUNET_STRINGS_relative_time_to_string (settle_time,
                                                        GNUNET_NO));
    GNUNET_SCHEDULER_add_delayed (settle_time, &do_announce, NULL);
  }
  else
  {
    GNUNET_SCHEDULER_add_now (&do_announce, NULL);
  }
  search_timeout_task =
    GNUNET_SCHEDULER_add_delayed (search_timeout_time, &search_timed_out, NULL);
}

References abort_task, cfg, do_announce(), GNUNET_assert, GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MILLISECONDS, num_peers, RegexPeer::peer_handle, peers, prof_start_time, prof_time, search_timed_out(), search_timeout_task, and search_timeout_time.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ master_controller_cb()

static void master_controller_cb	(	void *	cls,
		const struct GNUNET_TESTBED_EventInformation *	event
	)

static

Function that will be called whenever something in the testbed changes.

Parameters

cls	closure, NULL
event	information on what is happening

Definition at line 1156 of file gnunet-regex-profiler.c.

{
  switch (event->type)
  {
  case GNUNET_TESTBED_ET_CONNECT:
    printf (".");
    break;
 
  case GNUNET_TESTBED_ET_PEER_START:
    printf ("#");
    break;
 
  default:
    break;
  }
  fflush (stdout);
}

Referenced by run().

Here is the caller graph for this function:

◆ count_and_separate_strings()

static int count_and_separate_strings	(	char *	data,
		uint64_t	data_size,
		unsigned int	str_max
	)

static

Process the text buffer counting the non-empty lines and separating them with NULL characters, for later ease of copy using (as)printf.

Parameters

data	Memory buffer with strings.
data_size	Size of the data buffer in bytes.
str_max	Maximum number of strings to return.

Returns: Positive number of lines found in the buffer, GNUNET_SYSERR otherwise.

Definition at line 1191 of file gnunet-regex-profiler.c.

{
  char *buf;            // Keep track of last string to skip blank lines
  unsigned int offset;
  unsigned int str_cnt;
 
  buf = data;
  offset = 0;
  str_cnt = 0;
  while ((offset < (data_size - 1)) && (str_cnt < str_max))
  {
    offset++;
    if (((data[offset] == '\n')) &&
        (buf != &data[offset]))
    {
      data[offset] = '\0';
      str_cnt++;
      buf = &data[offset + 1];
    }
    else if ((data[offset] == '\n') ||
             (data[offset] == '\0'))
      buf = &data[offset + 1];
  }
  return str_cnt;
}

References data, and data_size.

Referenced by load_search_strings().

Here is the caller graph for this function:

◆ create_string_array()

static int create_string_array	(	char *	data,
		uint64_t	data_size,
		char ***	strings,
		unsigned int	str_cnt
	)

static

Allocate a string array and fill it with the prefixed strings from a pre-processed, NULL-separated memory region.

Parameters

data	Preprocessed memory with strings
data_size	Size of the data buffer in bytes.
strings	Address of the string array to be created. Must be freed by caller if function end in success.
str_cnt	String count. The data buffer should contain at least this many NULL-separated strings.

Returns: GNUNET_OK in ase of success, GNUNET_SYSERR otherwise. In case of error strings must not be freed.

Definition at line 1234 of file gnunet-regex-profiler.c.

{
  uint64_t offset;
  uint64_t len;
  unsigned int i;
 
  *strings = GNUNET_malloc (sizeof(char *) * str_cnt);
  offset = 0;
  for (i = 0; i < str_cnt; i++)
  {
    len = strlen (&data[offset]);
    if (offset + len >= data_size)
    {
      GNUNET_free (*strings);
      *strings = NULL;
      return GNUNET_SYSERR;
    }
    if (0 == len)   // empty line
    {
      offset++;
      i--;
      continue;
    }
 
    GNUNET_asprintf (&(*strings)[i],
                     "%s%s",
                     regex_prefix,
                     &data[offset]);
    offset += len + 1;
  }
  return GNUNET_OK;
}

References data, data_size, GNUNET_asprintf(), GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_SYSERR, and regex_prefix.

Referenced by load_search_strings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_search_strings()

static int load_search_strings	(	const char *	filename,
		char ***	strings,
		unsigned int	limit
	)

static

Load search strings from given filename.

One search string per line.

Parameters

filename	filename of the file containing the search strings.
strings	set of strings loaded from file. Caller needs to free this if number returned is greater than zero.
limit	upper limit on the number of strings read from the file

Returns: number of strings found in the file. GNUNET_SYSERR on error.

Definition at line 1279 of file gnunet-regex-profiler.c.

{
  char *data;
  uint64_t filesize;
  int str_cnt;
 
  /* Sanity checks */
  if (NULL == filename)
  {
    return GNUNET_SYSERR;
  }
  if (GNUNET_YES != GNUNET_DISK_file_test (filename))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Could not find search strings file %s\n", filename);
    return GNUNET_SYSERR;
  }
  if (GNUNET_OK !=
      GNUNET_DISK_file_size (filename,
                             &filesize,
                             GNUNET_YES,
                             GNUNET_YES))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Search strings file %s cannot be read.\n",
                filename);
    return GNUNET_SYSERR;
  }
  if (0 == filesize)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Search strings file %s is empty.\n",
                filename);
    return GNUNET_SYSERR;
  }
 
  /* Read data into memory */
  data = GNUNET_malloc (filesize + 1);
  if (filesize != GNUNET_DISK_fn_read (filename,
                                       data,
                                       filesize))
  {
    GNUNET_free (data);
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Could not read search strings file %s.\n",
                filename);
    return GNUNET_SYSERR;
  }
 
  /* Process buffer and build array */
  str_cnt = count_and_separate_strings (data, filesize, limit);
  if (GNUNET_OK != create_string_array (data, filesize, strings, str_cnt))
  {
    str_cnt = GNUNET_SYSERR;
  }
  GNUNET_free (data);
  return str_cnt;
}

References count_and_separate_strings(), create_string_array(), data, filename, GNUNET_DISK_file_size(), GNUNET_DISK_file_test(), GNUNET_DISK_fn_read(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_OK, GNUNET_SYSERR, and GNUNET_YES.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ run()

static void run	(	void *	cls,
		char const	args,
		const char *	cfgfile,
		const struct GNUNET_CONFIGURATION_Handle *	config
	)

static

Main function that will be run by the scheduler.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
config	configuration

Definition at line 1350 of file gnunet-regex-profiler.c.

{
  unsigned int nsearchstrs;
  unsigned int i;
  struct GNUNET_TIME_Relative abort_time;
 
  in_shutdown = GNUNET_NO;
 
  /* Check config */
  if (NULL == config)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("No configuration file given. Exiting\n"));
    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
    return;
  }
  cfg = GNUNET_CONFIGURATION_dup (config);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg, "REGEXPROFILER",
                                             "REGEX_PREFIX",
                                             &regex_prefix))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "regexprofiler",
                               "regex_prefix");
    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
    return;
  }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (cfg, "REGEXPROFILER",
                                             "PARALLEL_SEARCHES",
                                             &init_parallel_searches))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Configuration option \"PARALLEL_SEARCHES\" missing."
                " Using default (%d)\n", 10);
    init_parallel_searches = 10;
  }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_time (cfg, "REGEXPROFILER",
                                           "REANNOUNCE_PERIOD_MAX",
                                           &reannounce_period_max))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "reannounce_period_max not given. Using 10 minutes.\n");
    reannounce_period_max =
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 10);
  }
 
  /* Check arguments */
  if (NULL == policy_dir)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ (
                  "No policy directory specified on command line. Exiting.\n"));
    return;
  }
  if (GNUNET_YES != GNUNET_DISK_directory_test (policy_dir, GNUNET_YES))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Specified policies directory does not exist. Exiting.\n"));
    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
    return;
  }
  if (0 >= (int) (num_peers = GNUNET_DISK_directory_scan (policy_dir, NULL,
                                                          NULL)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("No files found in `%s'\n"),
                policy_dir);
    return;
  }
  GNUNET_CONFIGURATION_set_value_string (cfg, "REGEXPROFILER",
                                         "POLICY_DIR", policy_dir);
  if (GNUNET_YES != GNUNET_DISK_file_test (strings_file))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("No search strings file given. Exiting.\n"));
    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
    return;
  }
  nsearchstrs = load_search_strings (strings_file,
                                     &search_strings,
                                     num_peers);
  if (num_peers != nsearchstrs)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Error loading search strings.\n");
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "File (%s) does not contain enough strings (%u/%u).\n",
                strings_file, nsearchstrs, num_peers);
    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
    return;
  }
  if ((0 == num_peers) || (NULL == search_strings))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Error loading search strings. Exiting.\n"));
    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
    return;
  }
  for (i = 0; i < num_peers; i++)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "search string: %s\n",
                search_strings[i]);
 
  /* Check logfile */
  if ((NULL != data_filename) &&
      (NULL == (data_file =
                  GNUNET_DISK_file_open (data_filename,
                                         GNUNET_DISK_OPEN_READWRITE
                                         | GNUNET_DISK_OPEN_TRUNCATE
                                         | GNUNET_DISK_OPEN_CREATE,
                                         GNUNET_DISK_PERM_USER_READ
                                         | GNUNET_DISK_PERM_USER_WRITE))))
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                              "open",
                              data_filename);
    return;
  }
 
  /* Initialize peers */
  peers = GNUNET_malloc (sizeof(struct RegexPeer) * num_peers);
  for (i = 0; i < num_peers; i++)
    peers[i].id = i;
 
  GNUNET_CONFIGURATION_set_value_number (cfg,
                                         "TESTBED", "OVERLAY_RANDOM_LINKS",
                                         num_peers * 20);
  GNUNET_CONFIGURATION_set_value_number (cfg,
                                         "DHT", "FORCE_NSE",
                                         (long long unsigned)
                                         (log (num_peers) / log (2.0)));
  event_mask = 0LL;
/* For feedback about the start process activate these and pass master_cb */
  event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_START);
//   event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_STOP);
  event_mask |= (1LL << GNUNET_TESTBED_ET_CONNECT);
//   event_mask |= (1LL << GNUNET_TESTBED_ET_DISCONNECT);
  prof_start_time = GNUNET_TIME_absolute_get ();
  GNUNET_TESTBED_run (hosts_file,
                      cfg,
                      num_peers,
                      event_mask,
                      &master_controller_cb,
                      NULL,     /* master_controller_cb cls */
                      &test_master,
                      NULL);    /* test_master cls */
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_time (cfg, "TESTBED",
                                           "SETUP_TIMEOUT",
                                           &abort_time))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "SETUP_TIMEOUT not given. Using 15 minutes.\n");
    abort_time =
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15);
  }
  abort_time = GNUNET_TIME_relative_add (abort_time, GNUNET_TIME_UNIT_MINUTES);
  abort_task =
    GNUNET_SCHEDULER_add_delayed (abort_time,
                                  &do_abort,
                                  (void *) __LINE__);
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "setup_timeout: %s\n",
              GNUNET_STRINGS_relative_time_to_string (abort_time, GNUNET_YES));
}

References _, abort_task, cfg, config, data_file, data_filename, do_abort(), do_shutdown(), event_mask, GNUNET_CONFIGURATION_dup(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_CONFIGURATION_set_value_number(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_DISK_directory_scan(), GNUNET_DISK_directory_test(), GNUNET_DISK_file_open(), GNUNET_DISK_file_test(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_READWRITE, GNUNET_DISK_OPEN_TRUNCATE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_config_missing(), GNUNET_log_strerror_file, GNUNET_malloc, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_relative_add(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MINUTES, GNUNET_YES, hosts_file, in_shutdown, init_parallel_searches, load_search_strings(), master_controller_cb(), num_peers, peers, policy_dir, prof_start_time, reannounce_period_max, regex_prefix, search_strings, strings_file, and test_master().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ main()

int main	(	int	argc,
		char const	argv
	)

Main function.

Parameters

argc	argument count
argv	argument values

Returns: 0 on success

Definition at line 1531 of file gnunet-regex-profiler.c.

{
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_filename (
      'o',
      "output-file",
      "FILENAME",
      gettext_noop (
        "name of the file for writing statistics"),
      &data_filename),
    GNUNET_GETOPT_option_relative_time (
      't',
      "matching-timeout",
      "TIMEOUT",
      gettext_noop (
        "wait TIMEOUT before ending the experiment"),
      &search_timeout_time),
    GNUNET_GETOPT_option_filename (
      'p',
      "policy-dir",
      "DIRECTORY",
      gettext_noop ("directory with policy files"),
      &policy_dir),
    GNUNET_GETOPT_option_filename (
      's',
      "strings-file",
      "FILENAME",
      gettext_noop (
        "name of file with input strings"),
      &strings_file),
    GNUNET_GETOPT_option_filename (
      'H',
      "hosts-file",
      "FILENAME",
      gettext_noop (
        "name of file with hosts' names"),
      &hosts_file),
 
    GNUNET_GETOPT_OPTION_END
  };
  int ret;
 
  if (GNUNET_OK !=
      GNUNET_STRINGS_get_utf8_args (argc, argv,
                                    &argc, &argv))
    return 2;
  result = GNUNET_SYSERR;
  ret =
    GNUNET_PROGRAM_run (argc, argv,
                        "gnunet-regex-profiler",
                        _ ("Profiler for regex"),
                        options,
                        &run, NULL);
  if (GNUNET_OK != ret)
    return ret;
  if (GNUNET_OK != result)
    return 1;
  return 0;
}

References _, data_filename, gettext_noop, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_filename(), GNUNET_GETOPT_option_relative_time(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), GNUNET_SYSERR, hosts_file, options, policy_dir, result, ret, run(), search_timeout_time, and strings_file.

Here is the call graph for this function:

Variable Documentation

◆ in_shutdown

int in_shutdown

static

Set when shutting down to avoid making more queries.

Definition at line 180 of file gnunet-regex-profiler.c.

Referenced by announce_next_regex(), do_announce(), find_string(), find_timed_out(), regex_found_handler(), run(), and search_timed_out().

◆ peers

struct RegexPeer* peers

static

The array of peers; we fill this as the peers are given to us by the testbed.

Definition at line 185 of file gnunet-regex-profiler.c.

Referenced by announce_next_regex(), daemon_started(), do_collect_stats(), do_shutdown(), find_string(), run(), search_timed_out(), stats_cb(), and test_master().

◆ reg_handle

struct GNUNET_TESTBED_HostRegistrationHandle* reg_handle

static

Host registration handle.

Definition at line 190 of file gnunet-regex-profiler.c.

Referenced by do_shutdown().

◆ mc_proc

struct GNUNET_TESTBED_ControllerProc* mc_proc

static

Handle to the master controller process.

Definition at line 195 of file gnunet-regex-profiler.c.

Referenced by do_shutdown().

◆ mc

struct GNUNET_TESTBED_Controller* mc

static

Handle to the master controller.

Definition at line 200 of file gnunet-regex-profiler.c.

Referenced by disconnect(), do_shutdown(), error_handler(), GNUNET_CRYPTO_hmac_raw(), GNUNET_PEERSTORE_monitor_start(), GNUNET_TRANSPORT_monitor(), GNUNET_TRANSPORT_monitor_cancel(), handle_monitor_data(), handle_monitor_end(), handle_monitor_next(), handle_monitor_start(), handle_result(), handle_sync(), monitor_iterate_cb(), monitor_iteration_next(), monitor_sync(), mq_error_handler(), reconnect(), send_start_monitor(), and watch_notifier().

◆ cfg

struct GNUNET_CONFIGURATION_Handle* cfg

static

Handle to global configuration.

Definition at line 205 of file gnunet-regex-profiler.c.

Referenced by dht_ca(), do_shutdown(), run(), stats_ca(), and test_master().

◆ abort_task

struct GNUNET_SCHEDULER_Task* abort_task

static

Abort task identifier.

Definition at line 210 of file gnunet-regex-profiler.c.

Referenced by do_abort(), do_shutdown(), run(), and test_master().

◆ register_hosts_task

struct GNUNET_SCHEDULER_Task* register_hosts_task

static

Host registration task identifier.

Definition at line 215 of file gnunet-regex-profiler.c.

Referenced by do_shutdown().

◆ event_mask

uint64_t event_mask

static

Global event mask for all testbed events.

Definition at line 220 of file gnunet-regex-profiler.c.

Referenced by run().

◆ prof_start_time

struct GNUNET_TIME_Absolute prof_start_time

static

The starting time of a profiling step.

Definition at line 225 of file gnunet-regex-profiler.c.

Referenced by regex_found_handler(), run(), and test_master().

◆ prof_time

struct GNUNET_TIME_Relative prof_time

static

Duration profiling step has taken.

Definition at line 230 of file gnunet-regex-profiler.c.

Referenced by do_shutdown(), regex_found_handler(), and test_master().

◆ num_peers

unsigned int num_peers

static

Number of peers to be started by the profiler.

Definition at line 235 of file gnunet-regex-profiler.c.

Referenced by announce_next_regex(), daemon_started(), do_shutdown(), find_string(), regex_found_handler(), run(), search_timed_out(), stats_cb(), and test_master().

◆ result

int result

static

Global testing status.

Definition at line 240 of file gnunet-regex-profiler.c.

Referenced by _nss_gns_gethostbyaddr_r(), _nss_gns_gethostbyname2_r(), _nss_gns_gethostbyname_r(), auto_config_cb(), block_create2(), check_proof_of_work(), check_search_response(), clear_msg(), close_srv_handle_room(), convert_from_ed_to_curve(), create_internal(), database_shutdown(), decode_message(), decode_private_ecdsa_key(), dns_value_to_string(), do_abort(), do_reconnect(), ecdsa_symmetric_decrypt(), ecdsa_symmetric_encrypt(), eddsa_symmetric_decrypt(), eddsa_symmetric_encrypt(), ego_sign_data_cb(), elligator_direct_map(), evaluate_nfa(), expand_dollar(), extract_abs_time(), extract_abs_time_nbo(), extract_array_generic(), extract_blind_sign_priv(), extract_blind_sign_pub(), extract_bool(), extract_fixed_blob(), extract_int64(), extract_rel_time(), extract_result_cb(), extract_rsa_pub(), extract_rsa_public_key(), extract_rsa_sig(), extract_rsa_signature(), extract_string(), extract_timestamp(), extract_timestamp_nbo(), extract_uint16(), extract_uint32(), extract_uint64(), extract_utf8_string(), extract_var_blob(), extract_varsize_blob(), find_linked_hash(), find_op_by_id(), find_proof(), GCC_latency_observed(), get_cont(), get_service_peer_identity(), GNUNET_BIO_read(), GNUNET_BIO_read_spec_object(), GNUNET_BIO_read_spec_string(), GNUNET_BIO_read_string(), GNUNET_CRYPTO_decrypt_old(), GNUNET_CRYPTO_ecdhe_elligator_encoding(), GNUNET_CRYPTO_ecdsa_public_key_derive(), GNUNET_CRYPTO_eddsa_private_key_derive(), GNUNET_CRYPTO_eddsa_public_key_derive(), GNUNET_CRYPTO_edx25519_private_key_derive(), GNUNET_CRYPTO_edx25519_public_key_derive(), GNUNET_CRYPTO_encrypt_old(), GNUNET_CRYPTO_hash_create_random(), GNUNET_CRYPTO_hash_difference(), GNUNET_CRYPTO_hash_from_string2(), GNUNET_CRYPTO_hash_sum(), GNUNET_CRYPTO_hash_to_enc(), GNUNET_CRYPTO_hash_xor(), GNUNET_CRYPTO_hkdf(), GNUNET_CRYPTO_hkdf_v(), GNUNET_CRYPTO_kdf(), GNUNET_CRYPTO_kdf_v(), GNUNET_CRYPTO_mpi_scan_unsigned(), GNUNET_CRYPTO_mpi_scan_unsigned_le(), GNUNET_CRYPTO_paillier_hom_add(), GNUNET_CRYPTO_pow_hash(), GNUNET_CRYPTO_rsa_private_key_get_public(), GNUNET_CRYPTO_symmetric_decrypt(), GNUNET_CRYPTO_symmetric_encrypt(), GNUNET_DISK_file_read(), GNUNET_DISK_file_read_non_blocking(), GNUNET_DISK_fn_read(), GNUNET_FS_directory_scan_get_result(), GNUNET_FS_read_meta_data(), GNUNET_FS_read_spec_meta_data(), GNUNET_GNSRECORD_block_create(), GNUNET_GNSRECORD_block_create2(), GNUNET_GNSRECORD_block_create_unsigned(), GNUNET_GNSRECORD_check_pow(), GNUNET_GNSRECORD_pow_round(), GNUNET_HELLO_builder_to_url(), GNUNET_HELLO_sign_address(), GNUNET_HOSTLIST_client_start(), GNUNET_PQ_eval_prepared_multi_select(), GNUNET_PQ_eval_prepared_non_select(), GNUNET_PQ_eval_prepared_singleton_select(), GNUNET_PQ_eval_result(), GNUNET_PQ_event_notify(), GNUNET_PQ_exec_statements(), GNUNET_PQ_extract_result(), GNUNET_RECLAIM_attribute_list_dup(), GNUNET_RECLAIM_attribute_list_serialize(), GNUNET_RECLAIM_attribute_serialize(), GNUNET_RECLAIM_credential_list_dup(), GNUNET_RECLAIM_credential_list_serialize(), GNUNET_RECLAIM_credential_serialize(), GNUNET_RECLAIM_presentation_list_dup(), GNUNET_RECLAIM_presentation_list_serialize(), GNUNET_RECLAIM_presentation_serialize(), GNUNET_SETI_create(), GNUNET_SETU_create(), GNUNET_SQ_extract_result(), GNUNET_STRINGS_parse_ipv4_policy(), GNUNET_STRINGS_parse_ipv6_policy(), GNUNET_try_compression(), GNUNET_xmalloc_unchecked_(), GSF_consider_forwarding(), GSF_request_plan_reference_get_last_transmission_(), handle_arm_result(), handle_external_ip(), handle_gns_response(), handle_results(), handle_search_response(), handle_search_result(), init_callback(), init_cb(), ip_try_connect(), libgnunet_plugin_datacache_sqlite_done(), link_room_message(), main(), manage_subscribe(), numeric_reverse(), OIDC_generate_id_token_hmac(), OIDC_generate_id_token_rsa(), process_keys(), process_result_message(), read_from_buffer(), read_from_file(), read_spec_handler_int32(), read_spec_handler_int64(), read_spec_handler_meta_data(), read_spec_handler_string(), recalculate_path_desirability(), reconnect(), REGEX_INTERNAL_eval(), regex_next_edge(), regex_result_iterator(), request_room_message_step(), request_srv_room_message(), requester_callback(), ret_string(), rsa_sign_mpi(), run(), sign_pow_identity(), signal_result(), sq_prepare(), sql_exec(), sql_prepare(), start_callback(), start_p2p_processing(), state_set_compare(), stats_cb(), stop_callback(), stun_msg2str(), term_callback(), test_report_cb(), time_between(), and upnp_addr_change_cb().

◆ state

enum State state

current state of profiling

Definition at line 245 of file gnunet-regex-profiler.c.

Referenced by check_icmp_remote(), check_icmp_service(), check_tcp_data(), check_tcp_remote(), check_tcp_service(), check_udp_remote(), check_udp_service(), cleanup_s5r(), clear_message_state(), deserialize_unindex_file(), GCT_change_estate(), get_message_state_chain_hash(), get_message_state_merge_hash(), get_redirect_state(), handle_icmp_remote(), handle_icmp_service(), handle_tcp_data(), handle_tcp_remote(), handle_tcp_service(), handle_udp_remote(), handle_udp_service(), icmp_from_helper(), init_message_state(), intersection_accept(), intersection_evaluate(), iterate_initial_edge(), iterate_reachables(), load_message_state(), make_up_icmp_service_payload(), make_up_icmpv4_payload(), make_up_icmpv6_payload(), mark_as_reachable(), monitor_cb(), parse_definitions(), print_info(), print_plugin_event_info(), process_peer_iteration_cb(), process_peer_monitoring_cb(), reachability_iterator(), resolve_peer_address(), save_message_state(), setup_state_record(), state_remove_transition(), state_set_append(), tcp_from_helper(), udp_from_helper(), union_accept(), union_copy_state(), union_evaluate(), and update_message_state().

◆ policy_dir

char* policy_dir

static

Folder where policy files are stored.

Definition at line 250 of file gnunet-regex-profiler.c.

Referenced by main(), and run().

◆ hosts_file

char* hosts_file

static

File with hostnames where to execute the test.

Definition at line 255 of file gnunet-regex-profiler.c.

Referenced by main(), and run().

◆ strings_file

char* strings_file

static

File with the strings to look for.

Definition at line 260 of file gnunet-regex-profiler.c.

Referenced by main(), and run().

◆ search_strings

char** search_strings

static

Search strings (num_peers of them).

Definition at line 265 of file gnunet-regex-profiler.c.

Referenced by daemon_started(), do_shutdown(), and run().

◆ init_parallel_searches

long long unsigned int init_parallel_searches

static

How many searches are we going to start in parallel.

Definition at line 270 of file gnunet-regex-profiler.c.

Referenced by do_announce(), and run().

◆ parallel_searches

unsigned int parallel_searches

static

How many searches are running in parallel.

Definition at line 275 of file gnunet-regex-profiler.c.

Referenced by announce_next_regex(), find_string(), and regex_found_handler().

◆ strings_found

unsigned int strings_found

static

Number of strings found in the published regexes.

Definition at line 280 of file gnunet-regex-profiler.c.

Referenced by announce_next_regex(), regex_found_handler(), and search_timed_out().

◆ next_search

unsigned int next_search

static

Index of peer to start next announce/search.

Definition at line 285 of file gnunet-regex-profiler.c.

Referenced by announce_next_regex().

◆ search_timeout_task

struct GNUNET_SCHEDULER_Task* search_timeout_task

static

Search timeout task identifier.

Definition at line 290 of file gnunet-regex-profiler.c.

Referenced by announce_next_regex(), regex_found_handler(), and test_master().

◆ search_timeout_time

struct GNUNET_TIME_Relative search_timeout_time = { 60000 }

static

Search timeout in seconds.

Definition at line 295 of file gnunet-regex-profiler.c.

Referenced by main(), search_timed_out(), and test_master().

◆ data_file

struct GNUNET_DISK_FileHandle* data_file

static

File to log statistics to.

Definition at line 300 of file gnunet-regex-profiler.c.

Referenced by do_shutdown(), regex_found_handler(), run(), and stats_iterator().

◆ data_filename

char* data_filename

static

Filename to log statistics to.

Definition at line 305 of file gnunet-regex-profiler.c.

Referenced by main(), and run().

◆ regex_prefix

char* regex_prefix

static

Prefix used for regex announcing.

We need to prefix the search strings with it, in order to find something.

Definition at line 311 of file gnunet-regex-profiler.c.

Referenced by create_string_array(), and run().

◆ reannounce_period_max

struct GNUNET_TIME_Relative reannounce_period_max

static

What's the maximum regex reannounce period.

Definition at line 316 of file gnunet-regex-profiler.c.

Referenced by daemon_started(), and run().

Data Structures

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ FIND_TIMEOUT

Enumeration Type Documentation

◆ State

Function Documentation

◆ dht_connect_cb()

◆ dht_ca()

◆ dht_da()

◆ stats_connect_cb()

◆ announce_next_regex()

◆ do_shutdown()

◆ do_abort()

◆ stats_ca()

◆ stats_da()

◆ stats_iterator()

◆ stats_cb()

◆ do_collect_stats()

◆ find_string()

◆ regex_found_handler()

◆ search_timed_out()

◆ find_timed_out()

◆ daemon_started()

◆ do_announce()

◆ test_master()

◆ master_controller_cb()

◆ count_and_separate_strings()

◆ create_string_array()

◆ load_search_strings()

◆ run()

◆ main()

Variable Documentation

◆ in_shutdown

◆ peers

◆ reg_handle

◆ mc_proc

◆ mc

◆ cfg

◆ abort_task

◆ register_hosts_task

◆ event_mask

◆ prof_start_time

◆ prof_time

◆ num_peers

◆ result

◆ state

◆ policy_dir

◆ hosts_file

◆ strings_file

◆ search_strings

◆ init_parallel_searches

◆ parallel_searches

◆ strings_found

◆ next_search

◆ search_timeout_task

◆ search_timeout_time

◆ data_file

◆ data_filename

◆ regex_prefix

◆ reannounce_period_max