regex_internal_dht.c File Reference

library to announce regexes in the network and match strings against published regexes. More...

#include "platform.h"
#include "regex_internal_lib.h"
#include "regex_block_lib.h"
#include "gnunet_dht_service.h"
#include "gnunet_statistics_service.h"
#include "gnunet_constants.h"
#include "gnunet_signatures.h"

Include dependency graph for regex_internal_dht.c:

Go to the source code of this file.

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. More...
#define	DHT_TTL   GNUNET_TIME_UNIT_HOURS
	DHT record lifetime to use. More...
#define	DHT_OPT   GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE
	DHT options to set. More...

Functions
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. More...
struct REGEX_INTERNAL_Announcement *	REGEX_INTERNAL_announce (struct GNUNET_DHT_Handle *dht, const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const char *regex, uint16_t compression, struct GNUNET_STATISTICS_Handle *stats)
	Announce a regular expression: put all states of the automaton in the DHT. More...
void	REGEX_INTERNAL_reannounce (struct REGEX_INTERNAL_Announcement *h)
	Announce again a regular expression previously announced. More...
void	REGEX_INTERNAL_announce_cancel (struct REGEX_INTERNAL_Announcement *h)
	Clear all cached data used by a regex announce. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
void	REGEX_INTERNAL_search_cancel (struct REGEX_INTERNAL_Search *h)
	Cancel an ongoing regex search in the DHT and free all resources. More...

Detailed Description

library to announce regexes in the network and match strings against published regexes.

Author

Bartlomiej Polot

Definition in file regex_internal_dht.c.

Macro Definition Documentation

LOG

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

Definition at line 35 of file regex_internal_dht.c.

DHT_REPLICATION

#define DHT_REPLICATION   5

DHT replication level to use.

Definition at line 40 of file regex_internal_dht.c.

DHT_TTL

#define DHT_TTL   GNUNET_TIME_UNIT_HOURS

DHT record lifetime to use.

Definition at line 45 of file regex_internal_dht.c.

DHT_OPT

#define DHT_OPT   GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE

DHT options to set.

Definition at line 50 of file regex_internal_dht.c.

Function Documentation

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 96 of file regex_internal_dht.c.

{
  struct REGEX_INTERNAL_Announcement *h = cls;
  struct RegexBlock *block;
  size_t size;
  unsigned int i;
 
  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)
  {
    struct RegexAcceptBlock ab;
 
    LOG (GNUNET_ERROR_TYPE_INFO,
         "State %s is accepting, putting own id\n",
         GNUNET_h2s (key));
    size = sizeof(struct RegexAcceptBlock);
    ab.purpose.size = ntohl (sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
                             + sizeof(struct GNUNET_TIME_AbsoluteNBO)
                             + sizeof(struct GNUNET_HashCode));
    ab.purpose.purpose = ntohl (GNUNET_SIGNATURE_PURPOSE_REGEX_ACCEPT);
    ab.expiration_time = GNUNET_TIME_absolute_hton (
      GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_DHT_MAX_EXPIRATION));
    ab.key = *key;
    GNUNET_CRYPTO_eddsa_key_get_public (h->priv,
                                        &ab.peer.public_key);
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CRYPTO_eddsa_sign_ (h->priv,
                                              &ab.purpose,
                                              &ab.signature));
 
    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, key,
                    DHT_REPLICATION,
                    DHT_OPT | GNUNET_DHT_RO_RECORD_ROUTE,
                    GNUNET_BLOCK_TYPE_REGEX_ACCEPT,
                    size,
                    &ab,
                    GNUNET_TIME_relative_to_absolute (DHT_TTL),
                    NULL, NULL);
  }
  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, RegexAcceptBlock::expiration_time, GNUNET_assert, GNUNET_BLOCK_TYPE_REGEX, GNUNET_BLOCK_TYPE_REGEX_ACCEPT, GNUNET_CONSTANTS_DHT_MAX_EXPIRATION, GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_CRYPTO_eddsa_sign_(), GNUNET_DHT_put(), GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_h2s(), GNUNET_NO, GNUNET_OK, GNUNET_SIGNATURE_PURPOSE_REGEX_ACCEPT, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_hton(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, h, key, RegexAcceptBlock::key, LOG, RegexBlock::num_edges, RegexAcceptBlock::peer, proof, GNUNET_PeerIdentity::public_key, RegexAcceptBlock::purpose, GNUNET_CRYPTO_EccSignaturePurpose::purpose, REGEX_BLOCK_create(), RegexAcceptBlock::signature, GNUNET_CRYPTO_EccSignaturePurpose::size, 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,
		const struct GNUNET_CRYPTO_EddsaPrivateKey *	priv,
		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.
priv	our private key, 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 199 of file regex_internal_dht.c.

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

References dht, GNUNET_assert, GNUNET_new, h, REGEX_INTERNAL_Announcement::priv, 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 220 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 239 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 606 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 380 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 419 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 462 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, Result::data, 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, len, LOG, regex_find_path(), regex_next_edge(), Result::size, and 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 516 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,
       "* %lu, %lu, [%u]\n",
       (unsigned long) ctx->position,
       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 557 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, len, 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 697 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, len, 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 771 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 793 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 808 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: