GNUnet  0.11.x
Data Structures | Macros | Enumerations | Functions | Variables
gnunet-regex-profiler.c File Reference

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:

Go to the source code of this file.

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 , INIT ,
  CFG_REQUEST_QUEUED , SERVICE_CONNECTED , RC_INIT = 0 , RC_LINKED ,
  RC_PEERS_CREATED , RC_READY , RC_PEERS_SHUTDOWN
}
 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 RegexPeerpeers
 The array of peers; we fill this as the peers are given to us by the testbed. More...
 
static struct GNUNET_TESTBED_HostRegistrationHandlereg_handle
 Host registration handle. More...
 
static struct GNUNET_TESTBED_ControllerProcmc_proc
 Handle to the master controller process. More...
 
static struct GNUNET_TESTBED_Controllermc
 Handle to the master controller. More...
 
static struct GNUNET_CONFIGURATION_Handlecfg
 Handle to global configuration. More...
 
static struct GNUNET_SCHEDULER_Taskabort_task
 Abort task identifier. More...
 
static struct GNUNET_SCHEDULER_Taskregister_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_Tasksearch_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_FileHandledata_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.

INIT 

Initial state.

CFG_REQUEST_QUEUED 

The configuration request has been sent.

SERVICE_CONNECTED 

connected to service

RC_INIT 

Initial state.

RC_LINKED 

Controllers on given hosts started and linked.

RC_PEERS_CREATED 

Peers are created.

RC_READY 

The testbed run is ready and the master callback can be called now.

At this time the peers are all started and if a topology is provided in the configuration the topology would have been attempted

RC_PEERS_SHUTDOWN 

All peers shutdown (stopped and destroyed)

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

69 {
73  STATE_INIT = 0,
74 
79 
84 
89 
94 
99 
105 };
@ STATE_PEERS_CREATING
Creating peers.
@ STATE_SLAVES_STARTING
Starting slaves.
@ STATE_INIT
Initial state.
@ STATE_PEERS_LINKING
Linking peers.
@ STATE_SEARCH_REGEX
Matching strings against announced regexes.
@ STATE_PEERS_STARTING
Starting peers.
@ STATE_PEERS_DESTROYING
Destroying peers; we can do this as the controller takes care of stopping a peer if it is running.

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.

Parameters
clsinternal peer id.
opoperation handle.
ca_resultconnect adapter result.
emsgerror message.

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
clsinternal peer id.
opoperation handle.
ca_resultconnect adapter result.
emsgerror message.

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

1041 {
1042  struct RegexPeer *peer = (struct RegexPeer *) cls;
1043 
1044  if ((NULL != emsg) || (NULL == op) || (NULL == ca_result))
1045  {
1046  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "DHT connect failed: %s\n", emsg);
1047  GNUNET_assert (0);
1048  }
1049 
1050  GNUNET_assert (NULL != peer->dht_handle);
1051  GNUNET_assert (peer->op_handle == op);
1052  GNUNET_assert (peer->dht_handle == ca_result);
1053 
1054  peer->search_str_matched = GNUNET_NO;
1055  peer->search_handle = REGEX_INTERNAL_search (peer->dht_handle,
1056  peer->search_str,
1058  NULL);
1059  peer->prof_start_time = GNUNET_TIME_absolute_get ();
1060 }
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
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.
#define GNUNET_log(kind,...)
@ GNUNET_NO
Definition: gnunet_common.h:94
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
@ GNUNET_ERROR_TYPE_ERROR
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:94
struct REGEX_INTERNAL_Search * REGEX_INTERNAL_search(struct GNUNET_DHT_Handle *dht, const char *string, REGEX_INTERNAL_Found callback, void *callback_cls, struct GNUNET_STATISTICS_Handle *stats)
Search for a peer offering a regex matching certain string in the DHT.
Peer handles.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.

References GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NO, GNUNET_TIME_absolute_get(), op, peer, regex_found_handler(), and REGEX_INTERNAL_search().

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.

Parameters
clsnot used.
cfgconfiguration handle.
Returns

Opens a connection to the dht service.

Parameters
clsClosure (peer).
cfgConfiguration handle.
Returns

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

1073 {
1074  struct RegexPeer *peer = cls;
1075 
1076  peer->dht_handle = GNUNET_DHT_connect (cfg, 32);
1077 
1078  return peer->dht_handle;
1079 }
static struct GNUNET_CONFIGURATION_Handle * cfg
Handle to global configuration.
struct GNUNET_DHT_Handle * GNUNET_DHT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned int ht_len)
Initialize the connection with the DHT service.
Definition: dht_api.c:883

References cfg, GNUNET_DHT_connect(), and peer.

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.

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

Parameters
clsclosure
op_resultservice handle returned from the connect adapter
clsClosure (peer).
op_resultService handle returned from the connect adapter.

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

1090 {
1091  struct RegexPeer *peer = (struct RegexPeer *) cls;
1092 
1093  GNUNET_assert (peer->dht_handle == op_result);
1094 
1095  if (NULL != peer->search_handle)
1096  {
1097  REGEX_INTERNAL_search_cancel (peer->search_handle);
1098  peer->search_handle = NULL;
1099  }
1100 
1101  if (NULL != peer->dht_handle)
1102  {
1103  GNUNET_DHT_disconnect (peer->dht_handle);
1104  peer->dht_handle = NULL;
1105  }
1106 }
void GNUNET_DHT_disconnect(struct GNUNET_DHT_Handle *handle)
Shutdown connection with the DHT service.
Definition: dht_api.c:906
static int op_result(struct GNUNET_OP_Handle *h, uint64_t op_id, int64_t result_code, const void *data, uint16_t data_size, void **ctx, uint8_t cancel)
Remove an operation, and call its result callback (unless it was cancelled).
Definition: op.c:245
void REGEX_INTERNAL_search_cancel(struct REGEX_INTERNAL_Search *h)
Cancel an ongoing regex search in the DHT and free all resources.

References GNUNET_assert, GNUNET_DHT_disconnect(), op_result(), peer, and REGEX_INTERNAL_search_cancel().

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
clsthe 'struct RegexPeer' for which we connected to stats
opconnect operation handle
ca_resulthandle to stats service
emsgerror message on failure

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

648 {
649  struct RegexPeer *peer = cls;
650 
651  if ((NULL == ca_result) || (NULL != emsg))
652  {
654  "Failed to connect to statistics service on peer %u: %s\n",
655  peer->id, emsg);
656 
657  peer->stats_handle = NULL;
658  return;
659  }
660 
661  peer->stats_handle = ca_result;
662 
663  if (NULL == GNUNET_STATISTICS_get (peer->stats_handle, NULL, NULL,
664  &stats_cb,
665  &stats_iterator, peer))
666  {
668  "Could not get statistics of peer %u!\n", peer->id);
669  }
670 }
static int stats_iterator(void *cls, const char *subsystem, const char *name, uint64_t value, int is_persistent)
Process statistic values.
static void stats_cb(void *cls, int success)
Stats callback.
struct GNUNET_STATISTICS_GetHandle * GNUNET_STATISTICS_get(struct GNUNET_STATISTICS_Handle *handle, const char *subsystem, const char *name, GNUNET_STATISTICS_Callback cont, GNUNET_STATISTICS_Iterator proc, void *cls)
Get statistic from the peer.

References GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_STATISTICS_get(), peer, stats_cb(), 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
clsIndex of the next peer in the peers array.
clsClosure (unused).

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

992 {
993  struct RegexPeer *peer;
994 
995  if (GNUNET_YES == in_shutdown)
996  return;
997  if (next_search >= num_peers)
998  {
999  if (strings_found != num_peers)
1000  {
1001  struct GNUNET_TIME_Relative new_delay;
1002  if (NULL != search_timeout_task)
1007  NULL);
1008  }
1009  return;
1010  }
1011 
1012  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Starting daemon %u\n", next_search);
1013  peer = &peers[next_search];
1014  peer->daemon_op =
1016  peer->peer_handle,
1017  "regexprofiler",
1018  &daemon_started,
1019  peer,
1020  1);
1021  next_search++;
1023 }
static unsigned int next_search
Index of peer to start next announce/search.
static unsigned int parallel_searches
How many searches are running in parallel.
static int in_shutdown
Set when shutting down to avoid making more queries.
static struct GNUNET_SCHEDULER_Task * search_timeout_task
Search timeout task identifier.
static unsigned int strings_found
Number of strings found in the published regexes.
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.
static void search_timed_out(void *cls)
Connect by string timeout task.
static unsigned int num_peers
Number of peers to be started by the profiler.
static struct RegexPeer * peers
The array of peers; we fill this as the peers are given to us by the testbed.
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_ERROR_TYPE_INFO
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_peer_manage_service(void *op_cls, struct GNUNET_TESTBED_Peer *peer, const char *service_name, GNUNET_TESTBED_OperationCompletionCallback cb, void *cb_cls, unsigned int start)
Start or stop given service at a peer.
#define GNUNET_TIME_UNIT_MINUTES
One minute.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:453
Time for relative time used by GNUnet, in microseconds.

References daemon_started(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_TESTBED_peer_manage_service(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MINUTES, GNUNET_YES, in_shutdown, next_search, num_peers, parallel_searches, peer, 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
clsNULL

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

395 {
396  struct RegexPeer *peer;
397  unsigned int peer_cnt;
398  unsigned int search_str_cnt;
399  char output_buffer[512];
400  size_t size;
401 
402  if (NULL != abort_task)
403  {
405  abort_task = NULL;
406  }
407  if (NULL != register_hosts_task)
408  {
410  register_hosts_task = NULL;
411  }
412  for (peer_cnt = 0; peer_cnt < num_peers; peer_cnt++)
413  {
414  peer = &peers[peer_cnt];
415 
416  if ((GNUNET_YES != peer->search_str_matched) && (NULL != data_file) )
417  {
418  prof_time = GNUNET_TIME_absolute_get_duration (peer->prof_start_time);
419  size =
420  GNUNET_snprintf (output_buffer,
421  sizeof(output_buffer),
422  "%p Search string not found: %s (%d)\n"
423  "%p On peer: %u (%p)\n"
424  "%p After: %s\n",
425  peer, peer->search_str, peer->search_str_matched,
426  peer, peer->id, peer,
427  peer,
429  GNUNET_NO));
430  if (size != GNUNET_DISK_file_write (data_file, output_buffer, size))
431  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
432  }
433 
434  if (NULL != peers[peer_cnt].op_handle)
436  }
437 
438  if (NULL != data_file)
439  {
441  data_file = NULL;
442  }
443  for (search_str_cnt = 0;
444  search_str_cnt < num_peers && NULL != search_strings;
445  search_str_cnt++)
446  {
447  GNUNET_free (search_strings[search_str_cnt]);
448  }
450  search_strings = NULL;
451 
452  if (NULL != reg_handle)
453  {
455  reg_handle = NULL;
456  }
457  if (NULL != mc)
458  {
460  mc = NULL;
461  }
462  if (NULL != mc_proc)
463  {
465  mc_proc = NULL;
466  }
467  if (NULL != cfg)
468  {
470  cfg = NULL;
471  }
472 }
static struct GNUNET_SCHEDULER_Task * abort_task
Abort task identifier.
static struct GNUNET_TESTBED_Controller * mc
Handle to the master controller.
static struct GNUNET_TIME_Relative prof_time
Duration profiling step has taken.
static struct GNUNET_SCHEDULER_Task * register_hosts_task
Host registration task identifier.
static struct GNUNET_TESTBED_ControllerProc * mc_proc
Handle to the master controller process.
static char ** search_strings
Search strings (num_peers of them).
static struct GNUNET_TESTBED_HostRegistrationHandle * reg_handle
Host registration handle.
static struct GNUNET_DISK_FileHandle * data_file
File to log statistics to.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:686
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1306
@ GNUNET_ERROR_TYPE_WARNING
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_TESTBED_operation_done(struct GNUNET_TESTBED_Operation *operation)
This function is used to signal that the event information (struct GNUNET_TESTBED_EventInformation) f...
Definition: testbed_api.c:2045
void GNUNET_TESTBED_cancel_registration(struct GNUNET_TESTBED_HostRegistrationHandle *handle)
Cancel the pending registration.
void GNUNET_TESTBED_controller_stop(struct GNUNET_TESTBED_ControllerProc *cproc)
Stop the controller process (also will terminate all peers and controllers dependent on this controll...
void GNUNET_TESTBED_controller_disconnect(struct GNUNET_TESTBED_Controller *c)
Stop the given controller (also will terminate all peers and controllers dependent on this controller...
Definition: testbed_api.c:1721
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:405
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:543
static unsigned int size
Size of the "table".
Definition: peer.c:67
struct GNUNET_TESTBED_Operation * op_handle
Testbed operation handle for DHT.

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_TESTBED_cancel_registration(), GNUNET_TESTBED_controller_disconnect(), GNUNET_TESTBED_controller_stop(), GNUNET_TESTBED_operation_done(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, mc, mc_proc, num_peers, RegexPeer::op_handle, peer, peers, prof_time, reg_handle, register_hosts_task, 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
clsNULL

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

482 {
483  unsigned long i = (unsigned long) cls;
484 
486  "Aborting from line %lu...\n", i);
487  abort_task = NULL;
490 }
static void do_shutdown(void *cls)
Shutdown nicely.
static int result
Global testing status.
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296

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
clsclosure
cfgconfiguration 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 508 of file gnunet-regex-profiler.c.

510 {
511  return GNUNET_STATISTICS_create ("<driver>", cfg);
512 }
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.

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
clsclosure
op_resultservice handle returned from the connect adapter

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

524 {
525  struct RegexPeer *peer = cls;
526 
527  GNUNET_assert (op_result == peer->stats_handle);
528 
529  GNUNET_STATISTICS_destroy (peer->stats_handle, GNUNET_NO);
530  peer->stats_handle = NULL;
531 }
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).

References GNUNET_assert, GNUNET_NO, GNUNET_STATISTICS_destroy(), op_result(), and peer.

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
clsclosure
subsystemname of subsystem that created the statistic
namethe name of the datum
valuethe current value
is_persistentGNUNET_YES if the value is persistent, GNUNET_NO if not
Returns
GNUNET_OK to continue, GNUNET_SYSERR to abort iteration

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

549 {
550  struct RegexPeer *peer = cls;
551  char output_buffer[512];
552  size_t size;
553 
554  if (NULL == data_file)
555  {
557  "%p -> %s [%s]: %llu\n",
558  peer,
559  subsystem,
560  name,
561  (unsigned long long) value);
562  return GNUNET_OK;
563  }
564  size =
565  GNUNET_snprintf (output_buffer,
566  sizeof(output_buffer),
567  "%p [%s] %llu %s\n",
568  peer,
569  subsystem,
570  (unsigned long long) value,
571  name);
572  if (size != GNUNET_DISK_file_write (data_file, output_buffer, size))
574  "Unable to write to file!\n");
575 
576  return GNUNET_OK;
577 }
static char * value
Value of the record to add/remove.
static char * subsystem
Set to subsystem that we're going to get stats for (or NULL for all).
@ GNUNET_OK
Definition: gnunet_common.h:95
const char * name

References data_file, GNUNET_DISK_file_write(), GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_OK, GNUNET_snprintf(), name, peer, 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
clsclosure
successGNUNET_OK if statistics were successfully obtained, GNUNET_SYSERR if not.

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

591 {
592  static unsigned int peer_cnt;
593  struct RegexPeer *peer = cls;
594 
595  if (GNUNET_OK != success)
596  {
598  "Getting statistics for peer %u failed!\n",
599  peer->id);
600  return;
601  }
602 
603  GNUNET_assert (NULL != peer->op_handle);
604 
605  GNUNET_TESTBED_operation_done (peer->op_handle);
606  peer->op_handle = NULL;
607 
608  peer_cnt++;
609  peer = &peers[peer_cnt];
610 
611  fprintf (stderr, "s");
612  if (peer_cnt == num_peers)
613  {
615  "\nCollecting stats finished. Shutting down.\n");
617  result = GNUNET_OK;
618  }
619  else
620  {
621  peer->op_handle =
623  peer->peer_handle,
624  "statistics",
626  peer,
627  &stats_ca,
628  &stats_da,
629  peer);
630  }
631 }
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.
static void stats_da(void *cls, void *op_result)
Adapter function called to destroy a connection to statistics service.
static void * stats_ca(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
Adapter function called to establish a connection to statistics service.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
struct GNUNET_TESTBED_Operation * GNUNET_TESTBED_service_connect(void *op_cls, struct GNUNET_TESTBED_Peer *peer, const char *service_name, GNUNET_TESTBED_ServiceConnectCompletionCallback cb, void *cb_cls, GNUNET_TESTBED_ConnectAdapter ca, GNUNET_TESTBED_DisconnectAdapter da, void *cada_cls)
Connect to a service offered by the given peer.

References GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_shutdown(), GNUNET_TESTBED_operation_done(), GNUNET_TESTBED_service_connect(), num_peers, peer, 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
clsNULL

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

681 {
682  struct RegexPeer *peer = &peers[0];
683 
684  GNUNET_assert (NULL != peer->peer_handle);
685 
686  peer->op_handle =
688  peer->peer_handle,
689  "statistics",
691  peer,
692  &stats_ca,
693  &stats_da,
694  peer);
695 }

References GNUNET_assert, GNUNET_TESTBED_service_connect(), peer, 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
clsIndex of the next peer in the peers array.

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

880 {
881  unsigned int search_peer = (unsigned int) (long) cls;
882 
883  if ((search_peer >= num_peers) ||
884  (GNUNET_YES == in_shutdown))
885  return;
886 
888  "Searching for string \"%s\" on peer %d (%u||)\n",
889  peers[search_peer].search_str,
890  search_peer,
892 
893  peers[search_peer].op_handle =
895  peers[search_peer].peer_handle,
896  "dht",
898  &peers[search_peer],
899  &dht_ca,
900  &dht_da,
901  &peers[search_peer]);
902  GNUNET_assert (NULL != peers[search_peer].op_handle);
903  peers[search_peer].timeout
906  &peers[search_peer]);
907 }
static void dht_connect_cb(void *cls, struct GNUNET_TESTBED_Operation *op, void *ca_result, const char *emsg)
DHT connect callback.
static void dht_da(void *cls, void *op_result)
Adapter function called to destroy a connection to the DHT service.
static void * dht_ca(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
DHT connect adapter.
#define FIND_TIMEOUT
static void find_timed_out(void *cls)
Search timed out.
struct GNUNET_SCHEDULER_Task * timeout
Operation timeout.

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_TESTBED_service_connect(), 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
clsClosure provided in REGEX_INTERNAL_search.
idPeer providing a regex that matches the string.
get_pathPath of the get request.
get_path_lengthLength of get_path.
put_pathPath of the put request.
put_path_lengthLength of the put_path.

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

730 {
731  struct RegexPeer *peer = cls;
732  char output_buffer[512];
733  size_t size;
734 
735  if (GNUNET_YES == peer->search_str_matched)
736  {
738  "String %s on peer %u already matched!\n",
739  peer->search_str, peer->id);
740  return;
741  }
742 
743  strings_found++;
745 
746  if (NULL != peer->timeout)
747  {
748  GNUNET_SCHEDULER_cancel (peer->timeout);
749  peer->timeout = NULL;
750  if (GNUNET_NO == in_shutdown)
752  }
753 
754  if (NULL == id)
755  {
756  // FIXME not possible right now
758  "String matching timed out for string %s on peer %u (%i/%i)\n",
759  peer->search_str, peer->id, strings_found, num_peers);
760  peer->search_str_matched = GNUNET_SYSERR;
761  }
762  else
763  {
764  prof_time = GNUNET_TIME_absolute_get_duration (peer->prof_start_time);
765 
767  "String %s found on peer %u after %s (%i/%i) (%u||)\n",
768  peer->search_str, peer->id,
771 
772  peer->search_str_matched = GNUNET_YES;
773 
774  if (NULL != data_file)
775  {
776  size =
777  GNUNET_snprintf (output_buffer,
778  sizeof(output_buffer),
779  "%p Peer: %u\n"
780  "%p Search string: %s\n"
781  "%p Search duration: %s\n\n",
782  peer, peer->id,
783  peer, peer->search_str,
784  peer,
786  GNUNET_NO));
787 
788  if (size != GNUNET_DISK_file_write (data_file, output_buffer, size))
789  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Unable to write to file!\n");
790  }
791  }
792 
793  GNUNET_TESTBED_operation_done (peer->op_handle);
794  peer->op_handle = NULL;
795 
796  if (strings_found == num_peers)
797  {
800  "All strings successfully matched in %s\n",
802 
803  if (NULL != search_timeout_task)
804  {
806  search_timeout_task = NULL;
807  }
808 
809  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Collecting stats.\n");
811  }
812 }
static struct GNUNET_TIME_Absolute prof_start_time
The starting time of a profiling step.
static void announce_next_regex(void *cls)
Start announcing the next regex in the DHT.
static void do_collect_stats(void *cls)
Task to collect all statistics from all peers, will shutdown the profiler, when done.

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_TESTBED_operation_done(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, in_shutdown, num_peers, parallel_searches, peer, prof_start_time, prof_time, search_timeout_task, size, and strings_found.

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
clsNULL

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

823 {
824  unsigned int i;
825 
827  "Finding matches to all strings did not succeed after %s.\n",
829  GNUNET_NO));
831  "Found %i of %i strings\n", strings_found, num_peers);
832 
834  "Search timed out after %s."
835  "Collecting stats and shutting down.\n",
837  GNUNET_NO));
838 
840  for (i = 0; i < num_peers; i++)
841  {
842  if (NULL != peers[i].op_handle)
843  {
844  GNUNET_TESTBED_operation_done (peers[i].op_handle);
845  peers[i].op_handle = NULL;
846  }
847  }
849 }
static struct GNUNET_TIME_Relative search_timeout_time
Search timeout in seconds.

References do_collect_stats(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TESTBED_operation_done(), 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
clsIndex of the next peer in the peers array.

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

860 {
861  struct RegexPeer *p = cls;
862 
863  p->timeout = NULL;
865  "Searching for string \"%s\" on peer %d timed out.\n",
866  p->search_str,
867  p->id);
868  if (GNUNET_NO == in_shutdown)
870 }
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:37

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
clsNULL
opthe operation handle
emsgNULL on success; otherwise an error description

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

921 {
922  struct RegexPeer *peer = (struct RegexPeer *) cls;
923  unsigned long search_peer;
924  unsigned int i;
925 
926  GNUNET_TESTBED_operation_done (peer->daemon_op);
927  peer->daemon_op = NULL;
928  if (NULL != emsg)
929  {
931  "Failed to start/stop daemon at peer %u: %s\n", peer->id, emsg);
932  GNUNET_assert (0);
933  }
934  else
935  {
937  "Daemon %u started successfully\n", peer->id);
938  }
939 
940  /* Find a peer to look for a string matching the regex announced */
942  num_peers);
943  for (i = 0; peers[search_peer].search_str != NULL; i++)
944  {
945  search_peer = (search_peer + 1) % num_peers;
946  if (i > num_peers)
947  GNUNET_assert (0); /* we ran out of peers, must be a bug */
948  }
949  peers[search_peer].search_str = search_strings[peer->id];
950  peers[search_peer].search_str_matched = GNUNET_NO;
953  2),
954  &find_string,
955  (void *) search_peer);
956 }
static struct GNUNET_TIME_Relative reannounce_period_max
What's the maximum regex reannounce period.
static void find_string(void *cls)
Start searching for the next string in the DHT.
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
struct GNUNET_TIME_Relative GNUNET_TIME_relative_saturating_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Saturating multiply relative time by a given factor.
Definition: time.c:500
int search_str_matched
Set to GNUNET_YES if the peer successfully matched the above search string.
const char * search_str
Peer's search string.

References 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_TESTBED_operation_done(), GNUNET_TIME_relative_saturating_multiply(), num_peers, peer, 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
clsNULL
tcthe task context

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

968 {
969  unsigned int i;
970 
971  if (GNUNET_YES == in_shutdown)
972  return;
974  "Starting announce.\n");
975  for (i = 0; i < init_parallel_searches; i++)
976  {
978  " scheduling announce %u\n",
979  i);
981  }
982 }
static long long unsigned int init_parallel_searches
How many searches are we going to start in parallel.

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
clsNULL
hthe run handle
num_peers_number of peers in 'peers'
testbed_peershandle to peers run in the testbed. NULL upon timeout (see GNUNET_TESTBED_test_run()).
links_succeededthe number of overlay link connection attempts that succeeded
links_failedthe number of overlay link connection attempts that failed

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

1129 {
1130  unsigned int i;
1131 
1132  GNUNET_assert (num_peers_ == num_peers);
1133 
1136  "Testbed started in %s\n",
1138 
1139  if (NULL != abort_task)
1140  {
1142  abort_task = NULL;
1143  }
1144 
1145  for (i = 0; i < num_peers; i++)
1146  {
1148  }
1149  if (GNUNET_NO ==
1150  GNUNET_CONFIGURATION_get_value_yesno (cfg, "DHT", "DISABLE_TRY_CONNECT"))
1151  {
1152  struct GNUNET_TIME_Relative settle_time;
1153 
1154  settle_time =
1156  10 * num_peers);
1158  "Waiting for DHT for %s to settle new connections.\n\n",
1160  GNUNET_NO));
1161  GNUNET_SCHEDULER_add_delayed (settle_time, &do_announce, NULL);
1162  }
1163  else
1164  {
1166  }
1169 }
static void do_announce(void *cls)
Task to start the daemons on each peer so that the regexes are announced into the DHT.
static struct GNUNET_TESTBED_Peer ** testbed_peers
Handles to all of the running peers.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
struct GNUNET_TESTBED_Peer * peer_handle
The actual testbed peer handle.

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, search_timeout_time, and testbed_peers.

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
clsclosure, NULL
eventinformation on what is happening

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

1181 {
1182  switch (event->type)
1183  {
1185  printf (".");
1186  break;
1187 
1189  printf ("#");
1190  break;
1191 
1192  default:
1193  break;
1194  }
1195  fflush (stdout);
1196 }
@ GNUNET_TESTBED_ET_CONNECT
A connection between two peers was established.
@ GNUNET_TESTBED_ET_PEER_START
A peer has been started.
enum GNUNET_TESTBED_EventType type
Type of the event.

References GNUNET_TESTBED_ET_CONNECT, GNUNET_TESTBED_ET_PEER_START, and GNUNET_TESTBED_EventInformation::type.

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
dataMemory buffer with strings.
data_sizeSize of the data buffer in bytes.
str_maxMaximum number of strings to return.
Returns
Positive number of lines found in the buffer, GNUNET_SYSERR otherwise.

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

1217 {
1218  char *buf; // Keep track of last string to skip blank lines
1219  unsigned int offset;
1220  unsigned int str_cnt;
1221 
1222  buf = data;
1223  offset = 0;
1224  str_cnt = 0;
1225  while ((offset < (data_size - 1)) && (str_cnt < str_max))
1226  {
1227  offset++;
1228  if (((data[offset] == '\n')) &&
1229  (buf != &data[offset]))
1230  {
1231  data[offset] = '\0';
1232  str_cnt++;
1233  buf = &data[offset + 1];
1234  }
1235  else if ((data[offset] == '\n') ||
1236  (data[offset] == '\0'))
1237  buf = &data[offset + 1];
1238  }
1239  return str_cnt;
1240 }
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
uint32_t data
The data value.
static char buf[2048]

References buf, 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
dataPreprocessed memory with strings
data_sizeSize of the data buffer in bytes.
stringsAddress of the string array to be created. Must be freed by caller if function end in success.
str_cntString 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 1257 of file gnunet-regex-profiler.c.

1259 {
1260  uint64_t offset;
1261  uint64_t len;
1262  unsigned int i;
1263 
1264  *strings = GNUNET_malloc (sizeof(char *) * str_cnt);
1265  offset = 0;
1266  for (i = 0; i < str_cnt; i++)
1267  {
1268  len = strlen (&data[offset]);
1269  if (offset + len >= data_size)
1270  {
1271  GNUNET_free (*strings);
1272  *strings = NULL;
1273  return GNUNET_SYSERR;
1274  }
1275  if (0 == len) // empty line
1276  {
1277  offset++;
1278  i--;
1279  continue;
1280  }
1281 
1282  GNUNET_asprintf (&(*strings)[i],
1283  "%s%s",
1284  regex_prefix,
1285  &data[offset]);
1286  offset += len + 1;
1287  }
1288  return GNUNET_OK;
1289 }
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
static char * regex_prefix
Prefix used for regex announcing.
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_malloc(size)
Wrapper around malloc.

References data, data_size, GNUNET_asprintf(), GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_SYSERR, len, 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
filenamefilename of the file containing the search strings.
stringsset of strings loaded from file. Caller needs to free this if number returned is greater than zero.
limitupper 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 1302 of file gnunet-regex-profiler.c.

1305 {
1306  char *data;
1307  uint64_t filesize;
1308  int str_cnt;
1309 
1310  /* Sanity checks */
1311  if (NULL == filename)
1312  {
1313  return GNUNET_SYSERR;
1314  }
1316  {
1318  "Could not find search strings file %s\n", filename);
1319  return GNUNET_SYSERR;
1320  }
1321  if (GNUNET_OK !=
1323  &filesize,
1324  GNUNET_YES,
1325  GNUNET_YES))
1326  {
1328  "Search strings file %s cannot be read.\n",
1329  filename);
1330  return GNUNET_SYSERR;
1331  }
1332  if (0 == filesize)
1333  {
1335  "Search strings file %s is empty.\n",
1336  filename);
1337  return GNUNET_SYSERR;
1338  }
1339 
1340  /* Read data into memory */
1341  data = GNUNET_malloc (filesize + 1);
1342  if (filesize != GNUNET_DISK_fn_read (filename,
1343  data,
1344  filesize))
1345  {
1346  GNUNET_free (data);
1348  "Could not read search strings file %s.\n",
1349  filename);
1350  return GNUNET_SYSERR;
1351  }
1352 
1353  /* Process buffer and build array */
1354  str_cnt = count_and_separate_strings (data, filesize, limit);
1355  if (GNUNET_OK != create_string_array (data, filesize, strings, str_cnt))
1356  {
1357  str_cnt = GNUNET_SYSERR;
1358  }
1359  GNUNET_free (data);
1360  return str_cnt;
1361 }
static char * filename
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,...
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,...
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory).
Definition: disk.c:482
enum GNUNET_GenericReturnValue GNUNET_DISK_file_size(const char *filename, uint64_t *size, int include_symbolic_links, int single_file_mode)
Get the size of the file (or directory) of the given file (in bytes).
Definition: disk.c:222
ssize_t GNUNET_DISK_fn_read(const char *fn, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:664

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
clsclosure
argsremaining command-line arguments
cfgfilename of the configuration file used (for saving, can be NULL!)
configconfiguration

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

1377 {
1378  unsigned int nsearchstrs;
1379  unsigned int i;
1380  struct GNUNET_TIME_Relative abort_time;
1381 
1383 
1384  /* Check config */
1385  if (NULL == config)
1386  {
1388  _ ("No configuration file given. Exiting\n"));
1390  return;
1391  }
1393  if (GNUNET_OK !=
1394  GNUNET_CONFIGURATION_get_value_string (cfg, "REGEXPROFILER",
1395  "REGEX_PREFIX",
1396  &regex_prefix))
1397  {
1399  "regexprofiler",
1400  "regex_prefix");
1402  return;
1403  }
1404  if (GNUNET_OK !=
1405  GNUNET_CONFIGURATION_get_value_number (cfg, "REGEXPROFILER",
1406  "PARALLEL_SEARCHES",
1408  {
1410  "Configuration option \"PARALLEL_SEARCHES\" missing."
1411  " Using default (%d)\n", 10);
1413  }
1414  if (GNUNET_OK !=
1415  GNUNET_CONFIGURATION_get_value_time (cfg, "REGEXPROFILER",
1416  "REANNOUNCE_PERIOD_MAX",
1418  {
1420  "reannounce_period_max not given. Using 10 minutes.\n");
1423  }
1424 
1425  /* Check arguments */
1426  if (NULL == policy_dir)
1427  {
1429  _ (
1430  "No policy directory specified on command line. Exiting.\n"));
1431  return;
1432  }
1434  {
1436  _ ("Specified policies directory does not exist. Exiting.\n"));
1438  return;
1439  }
1440  if (0 >= (int) (num_peers = GNUNET_DISK_directory_scan (policy_dir, NULL,
1441  NULL)))
1442  {
1444  _ ("No files found in `%s'\n"),
1445  policy_dir);
1446  return;
1447  }
1448  GNUNET_CONFIGURATION_set_value_string (cfg, "REGEXPROFILER",
1449  "POLICY_DIR", policy_dir);
1451  {
1453  _ ("No search strings file given. Exiting.\n"));
1455  return;
1456  }
1457  nsearchstrs = load_search_strings (strings_file,
1458  &search_strings,
1459  num_peers);
1460  if (num_peers != nsearchstrs)
1461  {
1463  "Error loading search strings.\n");
1465  "File (%s) does not contain enough strings (%u/%u).\n",
1466  strings_file, nsearchstrs, num_peers);
1468  return;
1469  }
1470  if ((0 == num_peers) || (NULL == search_strings))
1471  {
1473  _ ("Error loading search strings. Exiting.\n"));
1475  return;
1476  }
1477  for (i = 0; i < num_peers; i++)
1479  "search string: %s\n",
1480  search_strings[i]);
1481 
1482  /* Check logfile */
1483  if ((NULL != data_filename) &&
1484  (NULL == (data_file =
1491  {
1493  "open",
1494  data_filename);
1495  return;
1496  }
1497 
1498  /* Initialize peers */
1499  peers = GNUNET_malloc (sizeof(struct RegexPeer) * num_peers);
1500  for (i = 0; i < num_peers; i++)
1501  peers[i].id = i;
1502 
1504  "TESTBED", "OVERLAY_RANDOM_LINKS",
1505  num_peers * 20);
1507  "DHT", "FORCE_NSE",
1508  (long long unsigned)
1509  (log (num_peers) / log (2.0)));
1510  event_mask = 0LL;
1511 /* For feedback about the start process activate these and pass master_cb */
1513 // event_mask |= (1LL << GNUNET_TESTBED_ET_PEER_STOP);
1515 // event_mask |= (1LL << GNUNET_TESTBED_ET_DISCONNECT);
1518  cfg,
1519  num_peers,
1520  event_mask,
1522  NULL, /* master_controller_cb cls */
1523  &test_master,
1524  NULL); /* test_master cls */
1525  if (GNUNET_OK !=
1527  "SETUP_TIMEOUT",
1528  &abort_time))
1529  {
1531  "SETUP_TIMEOUT not given. Using 15 minutes.\n");
1532  abort_time =
1534  }
1535  abort_time = GNUNET_TIME_relative_add (abort_time, GNUNET_TIME_UNIT_MINUTES);
1536  abort_task =
1537  GNUNET_SCHEDULER_add_delayed (abort_time,
1538  &do_abort,
1539  (void *) __LINE__);
1541  "setup_timeout: %s\n",
1543 }
static char * data_filename
Filename to log statistics to.
static char * policy_dir
Folder where policy files are stored.
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.
static void do_abort(void *cls)
abort task to run on test timed out
static uint64_t event_mask
Global event mask for all testbed events.
static char * hosts_file
File with hostnames where to execute the test.
static char * strings_file
File with the strings to look for.
static int load_search_strings(const char *filename, char ***strings, unsigned int limit)
Load search strings from given filename.
static void master_controller_cb(void *cls, const struct GNUNET_TESTBED_EventInformation *event)
Function that will be called whenever something in the testbed changes.
static const struct GNUNET_CONFIGURATION_Handle * config
void GNUNET_CONFIGURATION_set_value_string(struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, const char *value)
Set a configuration value that should be a string.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_time(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, struct GNUNET_TIME_Relative *time)
Get a configuration value that should be a relative time.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
void GNUNET_CONFIGURATION_set_value_number(struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long number)
Set a configuration value that should be a number.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_dup(const struct GNUNET_CONFIGURATION_Handle *cfg)
Duplicate an existing configuration object.
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1235
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_test(const char *fil, int is_readable)
Test if fil is a directory and listable.
Definition: disk.c:404
int GNUNET_DISK_directory_scan(const char *dir_name, GNUNET_FileNameCallback callback, void *callback_cls)
Scan a directory for files.
Definition: disk.c:814
@ GNUNET_DISK_OPEN_TRUNCATE
Truncate file if it exists.
@ GNUNET_DISK_OPEN_CREATE
Create file if it doesn't exist.
@ GNUNET_DISK_OPEN_READWRITE
Open the file for both reading and writing.
@ GNUNET_DISK_PERM_USER_READ
Owner can read.
@ GNUNET_DISK_PERM_USER_WRITE
Owner can write.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_DEBUG
void GNUNET_TESTBED_run(const char *host_filename, const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned int num_peers, uint64_t event_mask, GNUNET_TESTBED_ControllerCallback cc, void *cc_cls, GNUNET_TESTBED_TestMaster test_master, void *test_master_cls)
Convenience method for running a testbed with a single call.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_add(struct GNUNET_TIME_Relative a1, struct GNUNET_TIME_Relative a2)
Add relative times together.
Definition: time.c:554
#define _(String)
GNU gettext support macro.
Definition: platform.h:177

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_TESTBED_ET_CONNECT, GNUNET_TESTBED_ET_PEER_START, GNUNET_TESTBED_run(), 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
argcargument count
argvargument values
Returns
0 on success

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

1555 {
1558  'o',
1559  "output-file",
1560  "FILENAME",
1561  gettext_noop (
1562  "name of the file for writing statistics"),
1563  &data_filename),
1565  't',
1566  "matching-timeout",
1567  "TIMEOUT",
1568  gettext_noop (
1569  "wait TIMEOUT before ending the experiment"),
1572  'p',
1573  "policy-dir",
1574  "DIRECTORY",
1575  gettext_noop ("directory with policy files"),
1576  &policy_dir),
1578  's',
1579  "strings-file",
1580  "FILENAME",
1581  gettext_noop (
1582  "name of file with input strings"),
1583  &strings_file),
1585  'H',
1586  "hosts-file",
1587  "FILENAME",
1588  gettext_noop (
1589  "name of file with hosts' names"),
1590  &hosts_file),
1591 
1593  };
1594  int ret;
1595 
1596  if (GNUNET_OK !=
1597  GNUNET_STRINGS_get_utf8_args (argc, argv,
1598  &argc, &argv))
1599  return 2;
1601  ret =
1602  GNUNET_PROGRAM_run (argc, argv,
1603  "gnunet-regex-profiler",
1604  _ ("Profiler for regex"),
1605  options,
1606  &run, NULL);
1607  if (GNUNET_OK != ret)
1608  return ret;
1609  if (GNUNET_OK != result)
1610  return 1;
1611  return 0;
1612 }
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
#define gettext_noop(String)
Definition: gettext.h:69
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
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.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_filename(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a filename (automatically path expanded).
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_relative_time(char shortName, const char *name, const char *argumentHelp, const char *description, struct GNUNET_TIME_Relative *val)
Allow user to specify a struct GNUNET_TIME_Relative (using human-readable "fancy" time).
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:399
enum GNUNET_GenericReturnValue GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1196
Definition of a command line option.

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

◆ 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 220 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 220 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 ack_message_sent(), arm_ret_string(), auto_config_cb(), callback_set_handle_name(), check_reply(), check_search_response(), connect_bl_check_cont(), create_internal(), create_response(), database_shutdown(), decode_message(), decode_private_ecdsa_key(), dns_value_to_string(), do_abort(), do_reconnect(), ecdsa_symmetric_decrypt(), ecdsa_symmetric_encrypt(), evaluate_nfa(), expand_dollar(), extract_abs_time(), extract_abs_time_nbo(), extract_fixed_blob(), extract_result_cb(), extract_rsa_pub(), extract_rsa_sig(), extract_uint16(), extract_uint32(), extract_uint64(), extract_utf8_string(), extract_var_blob(), find_op_by_id(), find_proof(), fragmented_message_done(), GAS_handle_reservation_request(), GCC_latency_observed(), get_cont(), GNUNET_ABE_cpabe_decrypt(), GNUNET_ABE_cpabe_encrypt(), GNUNET_ABE_cpabe_serialize_key(), GNUNET_ABE_cpabe_serialize_master_key(), GNUNET_BIO_read(), GNUNET_BIO_read_meta_data(), GNUNET_BIO_read_spec_double(), GNUNET_BIO_read_spec_int32(), GNUNET_BIO_read_spec_meta_data(), GNUNET_BIO_read_spec_string(), GNUNET_BIO_read_string(), GNUNET_CRYPTO_cpabe_decrypt(), GNUNET_CRYPTO_cpabe_encrypt(), GNUNET_CRYPTO_cpabe_serialize_key(), GNUNET_CRYPTO_cpabe_serialize_master_key(), GNUNET_CRYPTO_ecdsa_public_key_derive(), GNUNET_CRYPTO_eddsa_private_key_derive(), GNUNET_CRYPTO_eddsa_public_key_derive(), GNUNET_CRYPTO_hash_create_random(), GNUNET_CRYPTO_hash_difference(), GNUNET_CRYPTO_hash_from_string2(), GNUNET_CRYPTO_hash_sum(), 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_HELLO_sign_address(), GNUNET_HOSTLIST_client_start(), GNUNET_IDENTITY_decrypt(), GNUNET_IDENTITY_encrypt(), GNUNET_MY_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_reply(), handle_results(), handle_search_response(), handle_search_result(), init_callback(), init_cb(), ip_try_connect(), libgnunet_plugin_datacache_sqlite_done(), main(), manage_subscribe(), numeric_reverse(), OIDC_generate_id_token(), plugin_env_session_start_bl_check_cont(), process_keys(), process_result_message(), qc_fragment_sent(), qc_message_sent(), read_from_buffer(), read_from_file(), recalculate_path_desirability(), reconnect(), REGEX_INTERNAL_eval(), regex_next_edge(), regex_result_iterator(), request_room_message(), request_room_message_step(), requester_callback(), ret_string(), rsa_sign_mpi(), send_disconnect_cont(), send_session_syn_ack_cont(), send_session_syn_cont(), service_manage_result_cb(), signal_result(), sq_prepare(), sql_exec(), sql_prepare(), start_callback(), start_p2p_processing(), state_set_compare(), stats_cb(), stop_callback(), stun_msg2str(), switch_address_bl_check_cont(), term_callback(), test_report_cb(), transmit_ping_if_allowed(), upnp_addr_change_cb(), and write_cpabe().

◆ state

enum State 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 290 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 311 of file gnunet-regex-profiler.c.

Referenced by daemon_started(), and run().