daemon that uses cadet to announce a regular expression. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "regex_internal_lib.h"
#include "regex_test_lib.h"
#include "gnunet_dht_service.h"
#include "gnunet_pils_service.h"
#include "gnunet_statistics_service.h"

Include dependency graph for gnunet-daemon-regexprofiler.c:

Functions
static void	shutdown_task (void *cls)
	Task run during shutdown.

static void	reannounce_regex (void *cls)
	Announce a previously announced regex reusing cached data.

static void	announce_regex (const char *regex)
	Announce the given regular expression using regex and the path compression length read from config.

static int	scan (void cls, const char filename)
	Scan through the policy_dir looking for the n-th filename.

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

int	main (int argc, char const argv)
	The main function of the regexprofiler service.

Variables
static int	global_ret
	Return value from 'main'.

static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Configuration we use.

static struct GNUNET_PILS_Handle *	pils_handle
	Handle to the pils service.

static struct GNUNET_STATISTICS_Handle *	stats_handle
	Handle to the statistics service.

static struct GNUNET_DHT_Handle *	dht_handle
	Peer's dht handle.

static struct REGEX_INTERNAL_Announcement *	announce_handle
	Peer's regex announce handle.

static struct GNUNET_SCHEDULER_Task *	reannounce_task
	Periodically reannounce regex.

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

static unsigned long long	max_path_compression
	Maximal path compression length for regex announcing.

static char *	policy_filename
	Name of the file containing policies that this peer should announce.

static char *	regex_prefix
	Prefix to add before every regex we're announcing.

static char *	rx_with_pfx
	Regex with prefix.

static unsigned int	rounds = 3
	How many put rounds should we do.

Detailed Description

daemon that uses cadet to announce a regular expression.

Used in conjunction with gnunet-regex-profiler to announce regexes on several peers without the need to explicitly connect to the cadet service running on the peer from within the profiler.

Author: Maximilian Szengel; Bartlomiej Polot

Definition in file gnunet-daemon-regexprofiler.c.

Function Documentation

◆ shutdown_task()

static void shutdown_task ( void * cls )

static

Task run during shutdown.

Parameters

cls unused

Definition at line 111 of file gnunet-daemon-regexprofiler.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "shutting down\n");
 
  if (NULL != announce_handle)
  {
    REGEX_INTERNAL_announce_cancel (announce_handle);
    announce_handle = NULL;
  }
  if (NULL != reannounce_task)
  {
    GNUNET_free_nz (GNUNET_SCHEDULER_cancel (reannounce_task));
    reannounce_task = NULL;
  }
  if (NULL != dht_handle)
  {
    GNUNET_DHT_disconnect (dht_handle);
    dht_handle = NULL;
  }
  if (NULL != pils_handle)
  {
    GNUNET_PILS_disconnect (pils_handle);
    pils_handle = NULL;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Daemon for %s shutting down\n",
              policy_filename);
}

References announce_handle, dht_handle, GNUNET_DHT_disconnect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_free_nz, GNUNET_log, GNUNET_PILS_disconnect(), GNUNET_SCHEDULER_cancel(), pils_handle, policy_filename, reannounce_task, and REGEX_INTERNAL_announce_cancel().

Here is the call graph for this function:

◆ reannounce_regex()

static void reannounce_regex ( void * cls )

static

Announce a previously announced regex reusing cached data.

Parameters

cls	Closure (regex to announce if needed).

Definition at line 148 of file gnunet-daemon-regexprofiler.c.

{
  char *regex = cls;
  struct GNUNET_TIME_Relative random_delay;
 
  reannounce_task = NULL;
  if (0 == rounds--)
  {
    global_ret = 0;
    GNUNET_SCHEDULER_shutdown ();
    GNUNET_free (regex);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Announcing regex: %s\n", regex);
  GNUNET_STATISTICS_update (stats_handle, "# regexes announced", 1, GNUNET_NO);
  if ((NULL == announce_handle) && (NULL != regex))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "First time, creating regex: %s\n",
                regex);
    announce_handle = REGEX_INTERNAL_announce (dht_handle,
                                               pils_handle,
                                               regex,
                                               (unsigned
                                                int) max_path_compression,
                                               stats_handle);
  }
  else
  {
    GNUNET_assert (NULL != announce_handle);
    REGEX_INTERNAL_reannounce (announce_handle);
  }
 
  random_delay =
    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS,
                                   GNUNET_CRYPTO_random_u32 (
                                     GNUNET_CRYPTO_QUALITY_WEAK,
                                     reannounce_period_max.rel_value_us));
  reannounce_task = GNUNET_SCHEDULER_add_delayed (random_delay,
                                                  &reannounce_regex, cls);
}

References announce_handle, dht_handle, global_ret, GNUNET_assert, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_update(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MICROSECONDS, max_path_compression, pils_handle, reannounce_period_max, reannounce_regex(), reannounce_task, REGEX_INTERNAL_announce(), REGEX_INTERNAL_reannounce(), GNUNET_TIME_Relative::rel_value_us, rounds, and stats_handle.

Referenced by announce_regex(), and reannounce_regex().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ announce_regex()

static void announce_regex ( const char * regex )

static

Announce the given regular expression using regex and the path compression length read from config.

Parameters

regex regular expression to announce on this peer's cadet.

Definition at line 198 of file gnunet-daemon-regexprofiler.c.

{
  char *copy;
 
  if ((NULL == regex) || (0 == strlen (regex)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Cannot announce empty regex\n");
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Daemon for %s starting\n",
              policy_filename);
  GNUNET_assert (NULL == reannounce_task);
  copy = GNUNET_strdup (regex);
  reannounce_task = GNUNET_SCHEDULER_add_now (&reannounce_regex,
                                              (void *) copy);
}

References GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, policy_filename, reannounce_regex(), and reannounce_task.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scan()

static int scan	(	void *	cls,
		const char *	filename
	)

static

Scan through the policy_dir looking for the n-th filename.

Parameters

cls	Closure (target number n).
filename	complete filename (absolute path).

Returns: GNUNET_OK to continue to iterate, GNUNET_NO to stop when found

Definition at line 227 of file gnunet-daemon-regexprofiler.c.

{
  long n = (long) cls;
  static long c = 0;
 
  if (c == n)
  {
    policy_filename = GNUNET_strdup (filename);
    return GNUNET_NO;
  }
  c++;
  return GNUNET_OK;
}

References filename, GNUNET_NO, GNUNET_OK, GNUNET_strdup, and policy_filename.

Referenced by run().

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 *	cfg_
	)

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!)
cfg_	configuration

Definition at line 251 of file gnunet-daemon-regexprofiler.c.

{
  char *regex = NULL;
  char **components;
  char *policy_dir;
  long long unsigned int peer_id;
 
  cfg = cfg_;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (cfg, "REGEXPROFILER",
                                             "MAX_PATH_COMPRESSION",
                                             &max_path_compression))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _
                (
                  "%s service is lacking key configuration settings (%s).  Exiting.\n"),
                "regexprofiler", "max_path_compression");
    global_ret = GNUNET_SYSERR;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg, "REGEXPROFILER",
                                             "POLICY_DIR", &policy_dir))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "REGEXPROFILER",
                               "POLICY_DIR");
    global_ret = GNUNET_SYSERR;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (cfg, "TESTBED",
                                             "PEERID", &peer_id))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "TESTBED", "PEERID");
    global_ret = GNUNET_SYSERR;
    GNUNET_free (policy_dir);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
  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");
    global_ret = GNUNET_SYSERR;
    GNUNET_free (policy_dir);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_time (cfg, "REGEXPROFILER",
                                           "REANNOUNCE_PERIOD_MAX",
                                           &reannounce_period_max))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "reannounce_period_max not given. Using 10 minutes.\n");
    reannounce_period_max =
      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 10);
  }
 
  pils_handle = GNUNET_PILS_connect (cfg, NULL, NULL);
  stats_handle = GNUNET_STATISTICS_create ("regexprofiler", cfg);
  dht_handle = GNUNET_DHT_connect (cfg, 1);
 
  if (NULL == dht_handle)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Could not acquire dht handle. Exiting.\n");
    global_ret = GNUNET_SYSERR;
    GNUNET_free (policy_dir);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
  /* Read regexes from policy files */
  GNUNET_assert (-1 != GNUNET_DISK_directory_scan (policy_dir, &scan,
                                                   (void *) (long) peer_id));
  if (NULL == (components = REGEX_TEST_read_from_file (policy_filename)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Policy file %s contains no policies. Exiting.\n",
                policy_filename);
    global_ret = GNUNET_SYSERR;
    GNUNET_free (policy_dir);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_free (policy_dir);
  regex = REGEX_TEST_combine (components, 16);
  REGEX_TEST_free_from_file (components);
 
  /* Announcing regexes from policy_filename */
  GNUNET_asprintf (&rx_with_pfx,
                   "%s(%s)(0|1|2|3|4|5|6|7|8|9|a|b|c|d|e|f)*",
                   regex_prefix,
                   regex);
  announce_regex (rx_with_pfx);
  GNUNET_free (regex);
  GNUNET_free (rx_with_pfx);
 
  /* Scheduled the task to clean up when shutdown is called */
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
                                 NULL);
}

References _, announce_regex(), cfg, dht_handle, global_ret, GNUNET_asprintf(), GNUNET_assert, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_DHT_connect(), GNUNET_DISK_directory_scan(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_log_config_missing(), GNUNET_OK, GNUNET_PILS_connect(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_SYSERR, GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MINUTES, max_path_compression, peer_id, pils_handle, policy_dir, policy_filename, reannounce_period_max, regex_prefix, REGEX_TEST_combine(), REGEX_TEST_free_from_file(), REGEX_TEST_read_from_file(), rx_with_pfx, scan(), shutdown_task, and stats_handle.

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
	)

The main function of the regexprofiler service.

Parameters

argc	number of arguments from the command line
argv	command line arguments

Returns: 0 ok, 1 on error

Definition at line 374 of file gnunet-daemon-regexprofiler.c.

{
  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_OPTION_END
  };
 
  return (GNUNET_OK ==
          GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                              argc, argv, "regexprofiler",
                              gettext_noop
                              (
                                "Daemon to announce regular expressions for the peer using cadet."),
                              options, &run, NULL)) ? global_ret : 1;
}