Use regex service from terminal. More...

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include "gnunet_common.h"
#include "gnunet_regex_service.h"
#include "gnunet_scheduler_lib.h"
#include "gnunet_time_lib.h"
#include "gnunet_util_lib.h"

Include dependency graph for gnunet-regex.c:

Functions
static void	shutdown_hook (void *cls)

static void	regex_found (void cls, const struct GNUNET_PeerIdentity id, const struct GNUNET_PeerIdentity get_path, unsigned int get_path_length, const struct GNUNET_PeerIdentity put_path, unsigned int put_path_length)
	Search callback function, invoked for every result that was found.

static void	print_announcement (void *cls)

static void	drop_announcement (void *cls)

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 **argv)
	The main function to announce regular expressions or observe announcing peers.

Variables
struct GNUNET_REGEX_Announcement *	announcement

struct GNUNET_REGEX_Search *	search

int	announcing

struct GNUNET_TIME_Relative	refresh_delay

uint16_t	compression

struct GNUNET_CONTAINER_MultiHashMap *	matches

struct GNUNET_SCHEDULER_Task *	shutdown_task

struct GNUNET_SCHEDULER_Task *	delay_task

char *	expression

Detailed Description

Use regex service from terminal.

Author: Tobias Frisch

Definition in file gnunet-regex.c.

Function Documentation

◆ shutdown_hook()

static void shutdown_hook ( void * cls )

static

Definition at line 52 of file gnunet-regex.c.

{
  shutdown_task = NULL;
 
  if (search)
    GNUNET_REGEX_search_cancel (search);
 
  if (announcement)
    GNUNET_REGEX_announce_cancel (announcement);
 
  if (delay_task)
    GNUNET_SCHEDULER_cancel (delay_task);
 
  if (matches)
    GNUNET_CONTAINER_multihashmap_destroy (matches);
 
  if (expression)
    GNUNET_free (expression);
}

References announcement, delay_task, expression, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_free, GNUNET_REGEX_announce_cancel(), GNUNET_REGEX_search_cancel(), GNUNET_SCHEDULER_cancel(), matches, search, and shutdown_task.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ regex_found()

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

static

Search callback function, invoked for every result that was found.

Parameters

cls	Closure provided in GNUNET_REGEX_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 84 of file gnunet-regex.c.

{
  struct GNUNET_HashCode hash;
  size_t get_path_size, put_path_size;
  unsigned int i;
 
  get_path_size = sizeof (struct GNUNET_PeerIdentity) * get_path_length;
  put_path_size = sizeof (struct GNUNET_PeerIdentity) * put_path_length;
 
  if (GNUNET_YES != GNUNET_CRYPTO_hkdf_gnunet (
        &hash, sizeof (hash),
        "regex_match", 11,
        id, sizeof (*id),
        GNUNET_CRYPTO_kdf_arg (get_path, get_path_size),
        GNUNET_CRYPTO_kdf_arg (put_path, put_path_size)))
    return;
 
  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (matches, &hash))
    return;
 
  printf ("%s ( get: %u, put: %u )\n", GNUNET_i2s_full (id), get_path_length,
          put_path_length);
 
  for (i = 0; i < get_path_length; i++)
    printf (" - get: %s\n", GNUNET_i2s_full (&(get_path[i])));
 
  for (i = 0; i < put_path_length; i++)
    printf (" - put: %s\n", GNUNET_i2s_full (&(put_path[i])));
 
  GNUNET_CONTAINER_multihashmap_put (
    matches, &hash, NULL,
    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
}

References GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_CRYPTO_hkdf_gnunet, GNUNET_CRYPTO_kdf_arg, GNUNET_i2s_full(), GNUNET_YES, and matches.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_announcement()

static void print_announcement ( void * cls )

static

Definition at line 125 of file gnunet-regex.c.

{
  delay_task = NULL;
 
  printf ("> %s\n", expression);
 
  if (cls)
    delay_task = GNUNET_SCHEDULER_add_delayed (refresh_delay,
                                               print_announcement,
                                               cls);
}

References delay_task, expression, GNUNET_SCHEDULER_add_delayed(), print_announcement(), and refresh_delay.

Referenced by drop_announcement(), print_announcement(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ drop_announcement()

static void drop_announcement ( void * cls )

static

Definition at line 139 of file gnunet-regex.c.

{
  delay_task = NULL;
 
  print_announcement (NULL);
 
  if (announcement)
  {
    GNUNET_REGEX_announce_cancel (announcement);
    announcement = NULL;
  }
 
  GNUNET_SCHEDULER_shutdown ();
}

References announcement, delay_task, GNUNET_REGEX_announce_cancel(), GNUNET_SCHEDULER_shutdown(), and print_announcement().

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

static

Main function that will be run by the scheduler.

Parameters

	[in/out]	cls closure
[in]	args	remaining command-line arguments
[in]	cfgfile	name of the configuration file used (for saving, can be NULL!)
[in]	cfg	configuration

Definition at line 164 of file gnunet-regex.c.

{
  int argc;
  size_t len, pos;
  unsigned int i;
 
  for (argc = 0; NULL != args[argc]; argc++)
    ;
 
  len = 0;
  for (i = 0; i < argc; i++)
    len += strlen (args[i]);
 
  if (argc > 0)
    len += (argc - 1);
 
  expression = GNUNET_malloc (len + 1);
  GNUNET_assert (expression);
  expression[len] = '\0';
  pos = 0;
  for (i = 0; i < argc; i++)
  {
    size_t s;
    s = strlen (args[i]);
    GNUNET_memcpy (expression + pos, args[i], s);
    pos += s;
 
    if (i + 1 < argc)
    {
      expression[pos] = ' ';
      pos++;
    }
  }
 
  matches = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
  shutdown_task = GNUNET_SCHEDULER_add_shutdown (shutdown_hook, NULL);
 
  GNUNET_assert (pos == len);
  if (announcing)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Announcing regular expression: %s\n",
                expression);
 
    announcement = GNUNET_REGEX_announce (cfg, expression, refresh_delay,
                                          compression);
 
    if (GNUNET_TIME_relative_is_zero (refresh_delay))
      delay_task = GNUNET_SCHEDULER_add_now (drop_announcement, NULL);
    else
      print_announcement (expression);
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Observing peers that announced matching regular expressions to: %s\n",
                expression);
 
    search = GNUNET_REGEX_search (cfg, expression, &regex_found, NULL);
  }
}

References announcement, announcing, cfg, compression, delay_task, drop_announcement(), expression, GNUNET_assert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_REGEX_announce(), GNUNET_REGEX_search(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_TIME_relative_is_zero(), matches, print_announcement(), refresh_delay, regex_found(), search, shutdown_hook(), and shutdown_task.

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

The main function to announce regular expressions or observe announcing peers.

Parameters

[in]	argc	number of arguments from the command line
[in]	argv	command line arguments

Returns: #EXIT_SUCCESS ok, #EXIT_FAILURE on error

Definition at line 237 of file gnunet-regex.c.

{
  const char *description =
    "Announce regular expressions and observe announcing peers.";
 
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_flag ('a', "announce",
                               "flag to announce an expression",
                               &announcing),
    GNUNET_GETOPT_option_relative_time ('r', "refresh", "DELAY",
                                        "refresh delay of announcement",
                                        &refresh_delay),
    GNUNET_GETOPT_option_uint16 ('c', "compression", "AMOUNT",
                                 "amount of characters per edge to squeeze",
                                 &compression),
    GNUNET_GETOPT_OPTION_END
  };
 
  return (GNUNET_OK ==
          GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                              argc,
                              argv,
                              "gnunet-regex [OPTIONS] EXPRESSION\0",
                              gettext_noop (description), options,
                              &run,
                              NULL) ? EXIT_SUCCESS : EXIT_FAILURE);
}