#include "gnunet_common.h"
#include "gnunet_util_lib.h"
#include "platform.h"
#include "regex_internal_lib.h"
#include "gnunet_dht_service.h"
#include "gnunet_pils_service.h"
#include "gnunet_statistics_service.h"
#include "gnunet_constants.h"
#include "gnunet_signatures.h"
#include "src/service/cadet/gnunet-service-cadet.h"

Include dependency graph for regex_internal_dht.c:

Data Structures
struct	REGEX_INTERNAL_Announcement
	Handle to store cached data about a regex announce. More...

struct	RegexSearchContext
	Struct to keep state of running searches that have consumed a part of the initial string. More...

struct	Result
	Type of values in `dht_get_results`. More...

struct	REGEX_INTERNAL_Search
	Struct to keep information of searches of services described by a regex using a user-provided string service description. More...

Macros
#define	LOG(kind, ...) GNUNET_log_from (kind, "regex-dht", __VA_ARGS__)

#define	DHT_REPLICATION 5
	DHT replication level to use.

#define	DHT_TTL GNUNET_TIME_UNIT_HOURS
	DHT record lifetime to use.

#define	DHT_OPT GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE
	DHT options to set.

Functions
static void	sign_accept_block (void cls, const struct GNUNET_PeerIdentity pid, const struct GNUNET_CRYPTO_EddsaSignature *sig)

static void	regex_iterator (void cls, const struct GNUNET_HashCode key, const char proof, int accepting, unsigned int num_edges, const struct REGEX_BLOCK_Edge edges)
	Regex callback iterator to store own service description in the DHT.

struct REGEX_INTERNAL_Announcement *	REGEX_INTERNAL_announce (struct GNUNET_DHT_Handle dht, struct GNUNET_PILS_Handle pils, const char regex, uint16_t compression, struct GNUNET_STATISTICS_Handle stats)
	Announce a regular expression: put all states of the automaton in the DHT.

void	REGEX_INTERNAL_reannounce (struct REGEX_INTERNAL_Announcement *h)
	Announce again a regular expression previously announced.

void	REGEX_INTERNAL_announce_cancel (struct REGEX_INTERNAL_Announcement *h)
	Clear all cached data used by a regex announce.

static void	regex_next_edge (const struct RegexBlock block, size_t size, struct RegexSearchContext ctx)
	Jump to the next edge, with the longest matching token.

static void	dht_get_string_accept_handler (void cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode key, const struct GNUNET_PeerIdentity trunc_peer, const struct GNUNET_DHT_PathElement get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement put_path, unsigned int put_path_length, enum GNUNET_BLOCK_Type type, size_t size, const void data)
	Function to process DHT string to regex matching.

static void	regex_find_path (const struct GNUNET_HashCode key, struct RegexSearchContext ctx)
	Find a path to a peer that offers a regex service compatible with a given string.

static void	dht_get_string_handler (void cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode key, const struct GNUNET_PeerIdentity trunc_peer, const struct GNUNET_DHT_PathElement get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement put_path, unsigned int put_path_length, enum GNUNET_BLOCK_Type type, size_t size, const void data)
	Function to process DHT string to regex matching.

static int	regex_result_iterator (void cls, const struct GNUNET_HashCode key, void *value)
	Iterator over found existing cadet regex blocks that match an ongoing search.

static int	regex_edge_iterator (void cls, const char token, size_t len, const struct GNUNET_HashCode *key)
	Iterator over edges in a regex block retrieved from the DHT.

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.

static int	regex_cancel_dht_get (void cls, const struct GNUNET_HashCode key, void *value)
	Iterator over hash map entries to cancel DHT GET requests after a successful connect_by_string.

static int	regex_free_result (void cls, const struct GNUNET_HashCode key, void *value)
	Iterator over hash map entries to free CadetRegexBlocks stored during the search for connect_by_string.

void	REGEX_INTERNAL_search_cancel (struct REGEX_INTERNAL_Search *h)
	Cancel an ongoing regex search in the DHT and free all resources.

Macro Definition Documentation

◆ LOG

#define LOG	(	kind,
		...
	)	GNUNET_log_from (kind, "regex-dht", __VA_ARGS__)

Definition at line 38 of file regex_internal_dht.c.

◆ DHT_REPLICATION

#define DHT_REPLICATION 5

DHT replication level to use.

Definition at line 43 of file regex_internal_dht.c.

◆ DHT_TTL

#define DHT_TTL GNUNET_TIME_UNIT_HOURS

DHT record lifetime to use.

Definition at line 48 of file regex_internal_dht.c.

◆ DHT_OPT

#define DHT_OPT GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE

DHT options to set.

Definition at line 53 of file regex_internal_dht.c.

Function Documentation

◆ sign_accept_block()

static void sign_accept_block	(	void *	cls,
		const struct GNUNET_PeerIdentity *	pid,
		const struct GNUNET_CRYPTO_EddsaSignature *	sig
	)

static

Definition at line 99 of file regex_internal_dht.c.

{
  struct REGEX_INTERNAL_Announcement *h = cls;
  size_t size;
 
  GNUNET_assert ((NULL != h->sign) && (NULL != h->ab));
 
  h->sign = NULL;
 
  GNUNET_memcpy (&(h->ab->signature), sig, sizeof (h->ab->signature));
  size = sizeof(struct RegexAcceptBlock);
 
  GNUNET_STATISTICS_update (h->stats, "# regex accepting blocks stored",
                            1, GNUNET_NO);
  GNUNET_STATISTICS_update (h->stats, "# regex accepting block bytes stored",
                            sizeof(struct RegexAcceptBlock), GNUNET_NO);
  (void)
  GNUNET_DHT_put (h->dht, &(h->ab->key),
                  DHT_REPLICATION,
                  DHT_OPT | GNUNET_DHT_RO_RECORD_ROUTE,
                  GNUNET_BLOCK_TYPE_REGEX_ACCEPT,
                  size,
                  h->ab,
                  GNUNET_TIME_relative_to_absolute (DHT_TTL),
                  NULL, NULL);
  GNUNET_free (h->ab);
  h->ab = NULL;
}

References DHT_OPT, DHT_REPLICATION, DHT_TTL, GNUNET_assert, GNUNET_BLOCK_TYPE_REGEX_ACCEPT, GNUNET_DHT_put(), GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_free, GNUNET_memcpy, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_relative_to_absolute(), h, and size.

Referenced by regex_iterator().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ regex_iterator()

static void regex_iterator	(	void *	cls,
		const struct GNUNET_HashCode *	key,
		const char *	proof,
		int	accepting,
		unsigned int	num_edges,
		const struct REGEX_BLOCK_Edge *	edges
	)

static

Regex callback iterator to store own service description in the DHT.

Parameters

cls	closure.
key	hash for current state.
proof	proof for current state.
accepting	GNUNET_YES if this is an accepting state, GNUNET_NO if not.
num_edges	number of edges leaving current state.
edges	edges leaving current state.

Definition at line 142 of file regex_internal_dht.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct REGEX_INTERNAL_Announcement *h = cls;
  struct RegexBlock *block;
  size_t size;
  unsigned int i;
 
  my_identity = GNUNET_PILS_get_identity (h->pils);
  if (NULL == my_identity)
    return;
 
  LOG (GNUNET_ERROR_TYPE_INFO,
       "DHT PUT for state %s with proof `%s' and %u edges:\n",
       GNUNET_h2s (key),
       proof,
       num_edges);
  for (i = 0; i < num_edges; i++)
  {
    LOG (GNUNET_ERROR_TYPE_INFO,
         "Edge %u `%s' towards %s\n",
         i,
         edges[i].label,
         GNUNET_h2s (&edges[i].destination));
  }
  if (GNUNET_YES == accepting)
  {
    if (NULL != h->sign)
    {
      GNUNET_PILS_cancel (h->sign);
      h->sign = NULL;
    }
    if (NULL != h->ab)
      GNUNET_free (h->ab);
    h->ab = GNUNET_new (struct RegexAcceptBlock);
    LOG (GNUNET_ERROR_TYPE_INFO,
         "State %s is accepting, putting own id\n",
         GNUNET_h2s (key));
    h->ab->purpose.size = ntohl (sizeof(struct GNUNET_CRYPTO_SignaturePurpose)
                                 + sizeof(struct GNUNET_TIME_AbsoluteNBO)
                                 + sizeof(struct GNUNET_HashCode));
    h->ab->purpose.purpose = ntohl (GNUNET_SIGNATURE_PURPOSE_REGEX_ACCEPT);
    h->ab->expiration_time = GNUNET_TIME_absolute_hton (
      GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_DHT_MAX_EXPIRATION));
    h->ab->key = *key;
    GNUNET_memcpy (&(h->ab->peer), my_identity,
                   sizeof (*my_identity));
    h->sign = GNUNET_PILS_sign_by_peer_identity (h->pils, &(h->ab->purpose),
                                                 &sign_accept_block, h);
    GNUNET_assert (NULL != h->sign);
  }
  block = REGEX_BLOCK_create (proof,
                              num_edges,
                              edges,
                              accepting,
                              &size);
  if (NULL == block)
    return;
  (void) GNUNET_DHT_put (h->dht,
                         key,
                         DHT_REPLICATION,
                         DHT_OPT,
                         GNUNET_BLOCK_TYPE_REGEX,
                         size,
                         block,
                         GNUNET_TIME_relative_to_absolute (DHT_TTL),
                         NULL,
                         NULL);
  GNUNET_STATISTICS_update (h->stats,
                            "# regex blocks stored",
                            1,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (h->stats,
                            "# regex block bytes stored",
                            size,
                            GNUNET_NO);
  GNUNET_free (block);
}

References DHT_OPT, DHT_REPLICATION, DHT_TTL, GNUNET_assert, GNUNET_BLOCK_TYPE_REGEX, GNUNET_CONSTANTS_DHT_MAX_EXPIRATION, GNUNET_DHT_put(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_h2s(), GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_PILS_cancel(), GNUNET_PILS_get_identity(), GNUNET_PILS_sign_by_peer_identity(), GNUNET_SIGNATURE_PURPOSE_REGEX_ACCEPT, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, h, key, LOG, my_identity, RegexBlock::num_edges, proof, REGEX_BLOCK_create(), sign_accept_block(), and size.

Referenced by REGEX_INTERNAL_reannounce().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ REGEX_INTERNAL_announce()

struct REGEX_INTERNAL_Announcement * REGEX_INTERNAL_announce	(	struct GNUNET_DHT_Handle *	dht,
		struct GNUNET_PILS_Handle *	pils,
		const char *	regex,
		uint16_t	compression,
		struct GNUNET_STATISTICS_Handle *	stats
	)

Announce a regular expression: put all states of the automaton in the DHT.

Does not free resources, must call REGEX_INTERNAL_announce_cancel() for that.

Parameters

dht	An existing and valid DHT service handle. CANNOT be NULL.
pils	our pils service handle, must remain valid until the announcement is cancelled
regex	Regular expression to announce.
compression	How many characters per edge can we squeeze?
stats	Optional statistics handle to report usage. Can be NULL.

Returns: Handle to reuse o free cached resources. Must be freed by calling REGEX_INTERNAL_announce_cancel().

Definition at line 240 of file regex_internal_dht.c.

{
  struct REGEX_INTERNAL_Announcement *h;
 
  GNUNET_assert ((NULL != dht) && (NULL != pils));
  h = GNUNET_new (struct REGEX_INTERNAL_Announcement);
  h->regex = regex;
  h->dht = dht;
  h->stats = stats;
  h->pils = pils;
  h->dfa = REGEX_INTERNAL_construct_dfa (regex, strlen (regex), compression);
  REGEX_INTERNAL_reannounce (h);
  return h;
}

References compression, dht, GNUNET_assert, GNUNET_new, h, pils, REGEX_INTERNAL_Announcement::regex, REGEX_INTERNAL_construct_dfa(), REGEX_INTERNAL_reannounce(), and stats.

Referenced by handle_announce(), and reannounce_regex().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ REGEX_INTERNAL_reannounce()

void REGEX_INTERNAL_reannounce ( struct REGEX_INTERNAL_Announcement * h )

Announce again a regular expression previously announced.

Does use caching to speed up process.

Parameters

h	Handle returned by a previous REGEX_INTERNAL_announce() call.

Definition at line 261 of file regex_internal_dht.c.

{
  GNUNET_assert (NULL != h->dfa);  /* make sure to call announce first */
  LOG (GNUNET_ERROR_TYPE_INFO,
       "REGEX_INTERNAL_reannounce: %s\n",
       h->regex);
  REGEX_INTERNAL_iterate_reachable_edges (h->dfa,
                                          &regex_iterator,
                                          h);
}

References GNUNET_assert, GNUNET_ERROR_TYPE_INFO, h, LOG, REGEX_INTERNAL_iterate_reachable_edges(), and regex_iterator().

Referenced by reannounce(), reannounce_regex(), and REGEX_INTERNAL_announce().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ REGEX_INTERNAL_announce_cancel()

void REGEX_INTERNAL_announce_cancel ( struct REGEX_INTERNAL_Announcement * h )

Clear all cached data used by a regex announce.

Does not close DHT connection.

Parameters

h	Handle returned by a previous REGEX_INTERNAL_announce() call.

Definition at line 280 of file regex_internal_dht.c.

{
  REGEX_INTERNAL_automaton_destroy (h->dfa);
  GNUNET_free (h);
}

References GNUNET_free, h, and REGEX_INTERNAL_automaton_destroy().

Referenced by client_disconnect_cb(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ regex_next_edge()

static void regex_next_edge	(	const struct RegexBlock *	block,
		size_t	size,
		struct RegexSearchContext *	ctx
	)

static

Jump to the next edge, with the longest matching token.

Parameters

block	Block found in the DHT.
size	Size of the block.
ctx	Context of the search.

Definition at line 649 of file regex_internal_dht.c.

{
  struct RegexSearchContext *new_ctx;
  struct REGEX_INTERNAL_Search *info = ctx->info;
  struct GNUNET_DHT_GetHandle *get_h;
  struct GNUNET_HashCode *hash;
  const char *rest;
  int result;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Next edge\n");
  /* Find the longest match for the current string position,
   * among tokens in the given block */
  ctx->longest_match = 0;
  result = REGEX_BLOCK_iterate (block, size,
                                &regex_edge_iterator, ctx);
  GNUNET_break (GNUNET_OK == result);
 
  /* Did anything match? */
  if (0 == ctx->longest_match)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "no match in block\n");
    return;
  }
 
  hash = &ctx->hash;
  new_ctx = GNUNET_new (struct RegexSearchContext);
  new_ctx->info = info;
  new_ctx->position = ctx->position + ctx->longest_match;
  GNUNET_array_append (info->contexts, info->n_contexts, new_ctx);
 
  /* Check whether we already have a DHT GET running for it */
  if (GNUNET_YES ==
      GNUNET_CONTAINER_multihashmap_contains (info->dht_get_handles, hash))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "GET for %s running, END\n",
         GNUNET_h2s (hash));
    GNUNET_CONTAINER_multihashmap_get_multiple (info->dht_get_results,
                                                hash,
                                                &regex_result_iterator,
                                                new_ctx);
    return;   /* We are already looking for it */
  }
 
  GNUNET_STATISTICS_update (info->stats, "# regex nodes traversed",
                            1, GNUNET_NO);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Following edges at %s for offset %u in `%s'\n",
       GNUNET_h2s (hash),
       (unsigned int) ctx->position,
       info->description);
  rest = &new_ctx->info->description[new_ctx->position];
  get_h =
    GNUNET_DHT_get_start (info->dht,       /* handle */
                          GNUNET_BLOCK_TYPE_REGEX,   /* type */
                          hash,       /* key to search */
                          DHT_REPLICATION,   /* replication level */
                          DHT_OPT,
                          rest,   /* xquery */
                          strlen (rest) + 1,       /* xquery bits */
                          &dht_get_string_handler, new_ctx);
  if (GNUNET_OK !=
      GNUNET_CONTAINER_multihashmap_put (info->dht_get_handles,
                                         hash,
                                         get_h,
                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
  {
    GNUNET_break (0);
    return;
  }
}

References ctx, REGEX_INTERNAL_Search::description, dht_get_string_handler(), DHT_OPT, DHT_REPLICATION, GNUNET_array_append, GNUNET_BLOCK_TYPE_REGEX, GNUNET_break, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_DHT_get_start(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_YES, info, RegexSearchContext::info, LOG, RegexSearchContext::position, REGEX_BLOCK_iterate(), regex_edge_iterator(), regex_result_iterator(), result, and size.

Referenced by dht_get_string_handler(), and regex_result_iterator().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dht_get_string_accept_handler()

static void dht_get_string_accept_handler	(	void *	cls,
		struct GNUNET_TIME_Absolute	exp,
		const struct GNUNET_HashCode *	key,
		const struct GNUNET_PeerIdentity *	trunc_peer,
		const struct GNUNET_DHT_PathElement *	get_path,
		unsigned int	get_path_length,
		const struct GNUNET_DHT_PathElement *	put_path,
		unsigned int	put_path_length,
		enum GNUNET_BLOCK_Type	type,
		size_t	size,
		const void *	data
	)

static

Function to process DHT string to regex matching.

Called on each result obtained for the DHT search.

Parameters

cls	Closure (search context).
exp	When will this value expire.
trunc_peer	truncated peer, or NULL if none was truncated
key	Key of the result.
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.
type	Type of the result.
size	Number of bytes in data.
data	Pointer to the result data.

Definition at line 421 of file regex_internal_dht.c.

{
  const struct RegexAcceptBlock *block = data;
  struct RegexSearchContext *ctx = cls;
  struct REGEX_INTERNAL_Search *info = ctx->info;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Regex result accept for %s (key %s)\n",
       info->description, GNUNET_h2s (key));
 
  GNUNET_STATISTICS_update (info->stats,
                            "# regex accepting blocks found",
                            1, GNUNET_NO);
  GNUNET_STATISTICS_update (info->stats,
                            "# regex accepting block bytes found",
                            size, GNUNET_NO);
  info->callback (info->callback_cls,
                  &block->peer,
                  get_path, get_path_length,
                  put_path, put_path_length);
}

References ctx, data, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_NO, GNUNET_STATISTICS_update(), info, key, LOG, RegexAcceptBlock::peer, and size.

Referenced by regex_find_path().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ regex_find_path()

static void regex_find_path	(	const struct GNUNET_HashCode *	key,
		struct RegexSearchContext *	ctx
	)

static

Find a path to a peer that offers a regex service compatible with a given string.

Parameters

key	The key of the accepting state.
ctx	Context containing info about the string, tunnel, etc.

Definition at line 460 of file regex_internal_dht.c.

{
  struct GNUNET_DHT_GetHandle *get_h;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Accept state found, now searching for paths to %s\n",
       GNUNET_h2s (key));
  get_h = GNUNET_DHT_get_start (ctx->info->dht,     /* handle */
                                GNUNET_BLOCK_TYPE_REGEX_ACCEPT, /* type */
                                key,     /* key to search */
                                DHT_REPLICATION, /* replication level */
                                DHT_OPT | GNUNET_DHT_RO_RECORD_ROUTE,
                                NULL, /* xquery */       // FIXME BLOOMFILTER
                                0, /* xquery bits */     // FIXME BLOOMFILTER SIZE
                                &dht_get_string_accept_handler, ctx);
  GNUNET_break (GNUNET_OK ==
                GNUNET_CONTAINER_multihashmap_put (ctx->info->dht_get_handles,
                                                   key,
                                                   get_h,
                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
}

References ctx, dht_get_string_accept_handler(), DHT_OPT, DHT_REPLICATION, GNUNET_BLOCK_TYPE_REGEX_ACCEPT, GNUNET_break, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_DHT_get_start(), GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_OK, key, and LOG.

Referenced by dht_get_string_handler(), and regex_result_iterator().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ dht_get_string_handler()

static void dht_get_string_handler	(	void *	cls,
		struct GNUNET_TIME_Absolute	exp,
		const struct GNUNET_HashCode *	key,
		const struct GNUNET_PeerIdentity *	trunc_peer,
		const struct GNUNET_DHT_PathElement *	get_path,
		unsigned int	get_path_length,
		const struct GNUNET_DHT_PathElement *	put_path,
		unsigned int	put_path_length,
		enum GNUNET_BLOCK_Type	type,
		size_t	size,
		const void *	data
	)

static

Function to process DHT string to regex matching.

Called on each result obtained for the DHT search.

Parameters

cls	closure (search context)
exp	when will this value expire
key	key of the result
trunc_peer	NULL if not truncated
get_path	path of the get request (not used)
get_path_length	length of get_path (not used)
put_path	path of the put request (not used)
put_path_length	length of the put_path (not used)
type	type of the result
size	number of bytes in data
data	pointer to the result data

TODO: re-issue the request after certain time? cancel after X results?

Definition at line 503 of file regex_internal_dht.c.

{
  const struct RegexBlock *block = data;
  struct RegexSearchContext *ctx = cls;
  struct REGEX_INTERNAL_Search *info = ctx->info;
  size_t len;
  struct Result *copy;
 
  LOG (GNUNET_ERROR_TYPE_INFO,
       "DHT GET result for %s (%s)\n",
       GNUNET_h2s (key), ctx->info->description);
  copy = GNUNET_malloc (sizeof(struct Result) + size);
  copy->size = size;
  copy->data = &copy[1];
  GNUNET_memcpy (&copy[1], block, size);
  GNUNET_break (GNUNET_OK ==
                GNUNET_CONTAINER_multihashmap_put (info->dht_get_results,
                                                   key, copy,
                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
  len = strlen (info->description);
  if (len == ctx->position) // String processed
  {
    if (GNUNET_YES == GNUNET_BLOCK_is_accepting (block, size))
    {
      regex_find_path (key, ctx);
    }
    else
    {
      LOG (GNUNET_ERROR_TYPE_INFO, "block not accepting!\n");
      /* FIXME REGEX this block not successful, wait for more? start timeout? */
    }
    return;
  }
  regex_next_edge (block, size, ctx);
}

References ctx, data, Result::data, GNUNET_BLOCK_is_accepting(), GNUNET_break, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_ERROR_TYPE_INFO, GNUNET_h2s(), GNUNET_malloc, GNUNET_memcpy, GNUNET_OK, GNUNET_YES, info, key, LOG, regex_find_path(), regex_next_edge(), size, and Result::size.

Referenced by REGEX_INTERNAL_search(), and regex_next_edge().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ regex_result_iterator()

static int regex_result_iterator	(	void *	cls,
		const struct GNUNET_HashCode *	key,
		void *	value
	)

static

Iterator over found existing cadet regex blocks that match an ongoing search.

Parameters

cls	Closure (current context)-
key	Current key code (key for cached block).
value	Value in the hash map (cached RegexBlock).

Returns: GNUNET_YES: we should always continue to iterate.

Definition at line 557 of file regex_internal_dht.c.

{
  struct Result *result = value;
  const struct RegexBlock *block = result->data;
  struct RegexSearchContext *ctx = cls;
 
  if ((GNUNET_YES ==
       GNUNET_BLOCK_is_accepting (block, result->size)) &&
      (ctx->position == strlen (ctx->info->description)))
  {
    LOG (GNUNET_ERROR_TYPE_INFO,
         "Found accepting known block\n");
    regex_find_path (key, ctx);
    return GNUNET_YES;   // We found an accept state!
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "* %llu, %llu, [%u]\n",
       (unsigned long long) ctx->position,
       (unsigned long long) strlen (ctx->info->description),
       GNUNET_BLOCK_is_accepting (block,
                                  result->size));
  regex_next_edge (block, result->size, ctx);
 
  GNUNET_STATISTICS_update (ctx->info->stats,
                            "# regex cadet blocks iterated",
                            1, GNUNET_NO);
 
  return GNUNET_YES;
}

References ctx, GNUNET_BLOCK_is_accepting(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, key, LOG, regex_find_path(), regex_next_edge(), result, and value.

Referenced by regex_next_edge().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ regex_edge_iterator()

static int regex_edge_iterator	(	void *	cls,
		const char *	token,
		size_t	len,
		const struct GNUNET_HashCode *	key
	)

static

Iterator over edges in a regex block retrieved from the DHT.

Parameters

cls	Closure (context of the search).
token	Token that follows to next state.
len	Length of token.
key	Hash of next state.

Returns: GNUNET_YES if should keep iterating, GNUNET_NO otherwise.

Definition at line 600 of file regex_internal_dht.c.

{
  struct RegexSearchContext *ctx = cls;
  struct REGEX_INTERNAL_Search *info = ctx->info;
  const char *current;
  size_t current_len;
 
  GNUNET_STATISTICS_update (info->stats, "# regex edges iterated",
                            1, GNUNET_NO);
  current = &info->description[ctx->position];
  current_len = strlen (info->description) - ctx->position;
  if (len > current_len)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Token too long, END\n");
    return GNUNET_YES;
  }
  if (0 != strncmp (current, token, len))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Token doesn't match, END\n");
    return GNUNET_YES;
  }
 
  if (len > ctx->longest_match)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Token is longer, KEEP\n");
    ctx->longest_match = len;
    ctx->hash = *key;
  }
  else
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Token is not longer, IGNORE\n");
  }
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "*    End of regex edge iterator\n");
  return GNUNET_YES;
}

References ctx, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, info, key, and LOG.

Referenced by regex_next_edge().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ REGEX_INTERNAL_search()

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.

The search runs until REGEX_INTERNAL_search_cancel() is called, even if results are returned.

Parameters

dht	An existing and valid DHT service handle.
string	String to match against the regexes in the DHT.
callback	Callback for found peers.
callback_cls	Closure for `callback`.
stats	Optional statistics handle to report usage. Can be NULL.

Returns: Handle to stop search and free resources. Must be freed by calling REGEX_INTERNAL_search_cancel().

Definition at line 740 of file regex_internal_dht.c.

{
  struct REGEX_INTERNAL_Search *h;
  struct GNUNET_DHT_GetHandle *get_h;
  struct RegexSearchContext *ctx;
  struct GNUNET_HashCode key;
  size_t size;
  size_t len;
 
  /* Initialize handle */
  GNUNET_assert (NULL != dht);
  GNUNET_assert (NULL != callback);
  h = GNUNET_new (struct REGEX_INTERNAL_Search);
  h->dht = dht;
  h->description = GNUNET_strdup (string);
  h->callback = callback;
  h->callback_cls = callback_cls;
  h->stats = stats;
  h->dht_get_handles = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
  h->dht_get_results = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
 
  /* Initialize context */
  len = strlen (string);
  size = REGEX_INTERNAL_get_first_key (string, len, &key);
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Initial key for `%s' is %s (based on `%.*s')\n",
       string,
       GNUNET_h2s (&key),
       (int) size,
       string);
  ctx = GNUNET_new (struct RegexSearchContext);
  ctx->position = size;
  ctx->info = h;
  GNUNET_array_append (h->contexts,
                       h->n_contexts,
                       ctx);
  /* Start search in DHT */
  get_h = GNUNET_DHT_get_start (h->dht,     /* handle */
                                GNUNET_BLOCK_TYPE_REGEX, /* type */
                                &key,     /* key to search */
                                DHT_REPLICATION, /* replication level */
                                DHT_OPT,
                                &h->description[size],           /* xquery */
                                // FIXME add BLOOMFILTER to exclude filtered peers
                                len + 1 - size,                /* xquery bits */
                                // FIXME add BLOOMFILTER SIZE
                                &dht_get_string_handler, ctx);
  GNUNET_break (
    GNUNET_OK ==
    GNUNET_CONTAINER_multihashmap_put (h->dht_get_handles,
                                       &key,
                                       get_h,
                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)
    );
 
  return h;
}

References ctx, dht, dht_get_string_handler(), DHT_OPT, DHT_REPLICATION, GNUNET_array_append, GNUNET_assert, GNUNET_BLOCK_TYPE_REGEX, GNUNET_break, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_DHT_get_start(), GNUNET_ERROR_TYPE_INFO, GNUNET_h2s(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_strdup, h, key, LOG, REGEX_INTERNAL_get_first_key(), size, and stats.

Referenced by dht_connect_cb(), and handle_search().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ regex_cancel_dht_get()

static int regex_cancel_dht_get	(	void *	cls,
		const struct GNUNET_HashCode *	key,
		void *	value
	)

static

Iterator over hash map entries to cancel DHT GET requests after a successful connect_by_string.

Parameters

cls	Closure (unused).
key	Current key code (unused).
value	Value in the hash map (get handle).

Returns: GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 814 of file regex_internal_dht.c.

{
  struct GNUNET_DHT_GetHandle *h = value;
 
  GNUNET_DHT_get_stop (h);
  return GNUNET_YES;
}

References GNUNET_DHT_get_stop(), GNUNET_YES, h, and value.

Referenced by REGEX_INTERNAL_search_cancel().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ regex_free_result()

static int regex_free_result	(	void *	cls,
		const struct GNUNET_HashCode *	key,
		void *	value
	)

static

Iterator over hash map entries to free CadetRegexBlocks stored during the search for connect_by_string.

Parameters

cls	Closure (unused).
key	Current key code (unused).
value	CadetRegexBlock in the hash map.

Returns: GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 836 of file regex_internal_dht.c.

{
  GNUNET_free (value);
  return GNUNET_YES;
}

References GNUNET_free, GNUNET_YES, and value.

Referenced by REGEX_INTERNAL_search_cancel().

Here is the caller graph for this function:

◆ REGEX_INTERNAL_search_cancel()

void REGEX_INTERNAL_search_cancel ( struct REGEX_INTERNAL_Search * h )

Cancel an ongoing regex search in the DHT and free all resources.

Stop search and free all data used by a REGEX_INTERNAL_search() call.

Parameters

h	the search context.

Definition at line 851 of file regex_internal_dht.c.

{
  unsigned int i;
 
  GNUNET_free (h->description);
  GNUNET_CONTAINER_multihashmap_iterate (h->dht_get_handles,
                                         &regex_cancel_dht_get, NULL);
  GNUNET_CONTAINER_multihashmap_iterate (h->dht_get_results,
                                         &regex_free_result, NULL);
  GNUNET_CONTAINER_multihashmap_destroy (h->dht_get_results);
  GNUNET_CONTAINER_multihashmap_destroy (h->dht_get_handles);
  if (0 < h->n_contexts)
  {
    for (i = 0; i < h->n_contexts; i++)
      GNUNET_free (h->contexts[i]);
    GNUNET_free (h->contexts);
  }
  GNUNET_free (h);
}

References GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, h, regex_cancel_dht_get(), and regex_free_result().

Referenced by client_disconnect_cb(), and dht_da().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Macros

Functions

Macro Definition Documentation

◆ LOG

◆ DHT_REPLICATION

◆ DHT_TTL

◆ DHT_OPT

Function Documentation

◆ sign_accept_block()

◆ regex_iterator()

◆ REGEX_INTERNAL_announce()

◆ REGEX_INTERNAL_reannounce()

◆ REGEX_INTERNAL_announce_cancel()

◆ regex_next_edge()

◆ dht_get_string_accept_handler()

◆ regex_find_path()

◆ dht_get_string_handler()

◆ regex_result_iterator()

◆ regex_edge_iterator()

◆ REGEX_INTERNAL_search()

◆ regex_cancel_dht_get()

◆ regex_free_result()

◆ REGEX_INTERNAL_search_cancel()