GNUnet  0.17.6
Data Structures | Macros | Functions
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_AnnouncementREGEX_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_SearchREGEX_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

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
clsclosure.
keyhash for current state.
proofproof for current state.
acceptingGNUNET_YES if this is an accepting state, GNUNET_NO if not.
num_edgesnumber of edges leaving current state.
edgesedges leaving current state.

Definition at line 96 of file regex_internal_dht.c.

102 {
103  struct REGEX_INTERNAL_Announcement *h = cls;
104  struct RegexBlock *block;
105  size_t size;
106  unsigned int i;
107 
109  "DHT PUT for state %s with proof `%s' and %u edges:\n",
110  GNUNET_h2s (key),
111  proof,
112  num_edges);
113  for (i = 0; i < num_edges; i++)
114  {
116  "Edge %u `%s' towards %s\n",
117  i,
118  edges[i].label,
119  GNUNET_h2s (&edges[i].destination));
120  }
121  if (GNUNET_YES == accepting)
122  {
123  struct RegexAcceptBlock ab;
124 
126  "State %s is accepting, putting own id\n",
127  GNUNET_h2s (key));
128  size = sizeof(struct RegexAcceptBlock);
129  ab.purpose.size = ntohl (sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
130  + sizeof(struct GNUNET_TIME_AbsoluteNBO)
131  + sizeof(struct GNUNET_HashCode));
132  ab.purpose.purpose = ntohl (GNUNET_SIGNATURE_PURPOSE_REGEX_ACCEPT);
133  ab.expiration_time = GNUNET_TIME_absolute_hton (
135  ab.key = *key;
137  &ab.peer.public_key);
140  &ab.purpose,
141  &ab.signature));
142 
143  GNUNET_STATISTICS_update (h->stats, "# regex accepting blocks stored",
144  1, GNUNET_NO);
145  GNUNET_STATISTICS_update (h->stats, "# regex accepting block bytes stored",
146  sizeof(struct RegexAcceptBlock), GNUNET_NO);
147  (void)
148  GNUNET_DHT_put (h->dht, key,
152  size,
153  &ab,
155  NULL, NULL);
156  }
157  block = REGEX_BLOCK_create (proof,
158  num_edges,
159  edges,
160  accepting,
161  &size);
162  if (NULL == block)
163  return;
164  (void) GNUNET_DHT_put (h->dht,
165  key,
167  DHT_OPT,
169  size,
170  block,
172  NULL,
173  NULL);
174  GNUNET_STATISTICS_update (h->stats,
175  "# regex blocks stored",
176  1,
177  GNUNET_NO);
178  GNUNET_STATISTICS_update (h->stats,
179  "# regex block bytes stored",
180  size,
181  GNUNET_NO);
182  GNUNET_free (block);
183 }
@ GNUNET_BLOCK_TYPE_REGEX_ACCEPT
Block to store a cadet regex accepting state.
@ GNUNET_BLOCK_TYPE_REGEX
Block to store a cadet regex state.
#define GNUNET_SIGNATURE_PURPOSE_REGEX_ACCEPT
Accept state in regex DFA.
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
struct GNUNET_HashCode key
The key used in the DHT.
static uint64_t proof
Definition: gnunet-scrypt.c:48
#define GNUNET_CONSTANTS_DHT_MAX_EXPIRATION
How long do we cache records at most in the DHT?
void GNUNET_CRYPTO_eddsa_key_get_public(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:197
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_sign_(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, const struct GNUNET_CRYPTO_EccSignaturePurpose *purpose, struct GNUNET_CRYPTO_EddsaSignature *sig)
EdDSA sign a given block.
Definition: crypto_ecc.c:619
struct GNUNET_DHT_PutHandle * GNUNET_DHT_put(struct GNUNET_DHT_Handle *handle, const struct GNUNET_HashCode *key, uint32_t desired_replication_level, enum GNUNET_DHT_RouteOption options, enum GNUNET_BLOCK_Type type, size_t size, const void *data, struct GNUNET_TIME_Absolute exp, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
Perform a PUT operation storing data in the DHT.
Definition: dht_api.c:1090
@ GNUNET_DHT_RO_RECORD_ROUTE
We should keep track of the route that the message took in the P2P network.
@ GNUNET_OK
Definition: gnunet_common.h:99
@ GNUNET_YES
@ GNUNET_NO
Definition: gnunet_common.h:98
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:315
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:637
static unsigned int size
Size of the "table".
Definition: peer.c:67
struct RegexBlock * REGEX_BLOCK_create(const char *proof, unsigned int num_edges, const struct REGEX_BLOCK_Edge *edges, int accepting, size_t *rsize)
Construct a regex block to be stored in the DHT.
#define DHT_TTL
DHT record lifetime to use.
#define DHT_REPLICATION
DHT replication level to use.
#define LOG(kind,...)
#define DHT_OPT
DHT options to set.
header of what an ECC signature signs this must be followed by "size - 8" bytes of the actual signed ...
A 512-bit hashcode.
Time for absolute time used by GNUnet, in microseconds and in network byte order.
Handle to store cached data about a regex announce.
Block to announce a peer accepting a state.
Definition: block_regex.h:50
Block to announce a regex state.
uint16_t num_edges
Number of edges parting from this state.

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
dhtAn existing and valid DHT service handle. CANNOT be NULL.
privour private key, must remain valid until the announcement is cancelled
regexRegular expression to announce.
compressionHow many characters per edge can we squeeze?
statsOptional 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.

204 {
206 
207  GNUNET_assert (NULL != dht);
209  h->regex = regex;
210  h->dht = dht;
211  h->stats = stats;
212  h->priv = priv;
213  h->dfa = REGEX_INTERNAL_construct_dfa (regex, strlen (regex), compression);
215  return h;
216 }
static struct GNUNET_DHT_Handle * dht
Handle to the DHT.
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct REGEX_INTERNAL_Automaton * REGEX_INTERNAL_construct_dfa(const char *regex, const size_t len, unsigned int max_path_len)
Construct DFA for the given 'regex' of length 'len'.
void REGEX_INTERNAL_reannounce(struct REGEX_INTERNAL_Announcement *h)
Announce again a regular expression previously announced.
const struct GNUNET_CRYPTO_EddsaPrivateKey * priv
Our private key.
const char * regex
Regular expression.

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
hHandle returned by a previous REGEX_INTERNAL_announce call().

Definition at line 226 of file regex_internal_dht.c.

227 {
228  GNUNET_assert (NULL != h->dfa); /* make sure to call announce first */
230  "REGEX_INTERNAL_reannounce: %s\n",
231  h->regex);
234  h);
235 }
void REGEX_INTERNAL_iterate_reachable_edges(struct REGEX_INTERNAL_Automaton *a, REGEX_INTERNAL_KeyIterator iterator, void *iterator_cls)
Iterate over all edges of automaton 'a' that are reachable from a state with a proof of at least GNUN...
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.

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
hHandle returned by a previous REGEX_INTERNAL_announce() call.

Definition at line 245 of file regex_internal_dht.c.

246 {
248  GNUNET_free (h);
249 }
void REGEX_INTERNAL_automaton_destroy(struct REGEX_INTERNAL_Automaton *a)
Free the memory allocated by constructing the REGEX_INTERNAL_Automaton data structure.

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
blockBlock found in the DHT.
sizeSize of the block.
ctxContext of the search.

Definition at line 612 of file regex_internal_dht.c.

615 {
616  struct RegexSearchContext *new_ctx;
617  struct REGEX_INTERNAL_Search *info = ctx->info;
618  struct GNUNET_DHT_GetHandle *get_h;
619  struct GNUNET_HashCode *hash;
620  const char *rest;
621  int result;
622 
623  LOG (GNUNET_ERROR_TYPE_DEBUG, "Next edge\n");
624  /* Find the longest match for the current string position,
625  * among tokens in the given block */
626  ctx->longest_match = 0;
627  result = REGEX_BLOCK_iterate (block, size,
630 
631  /* Did anything match? */
632  if (0 == ctx->longest_match)
633  {
635  "no match in block\n");
636  return;
637  }
638 
639  hash = &ctx->hash;
640  new_ctx = GNUNET_new (struct RegexSearchContext);
641  new_ctx->info = info;
642  new_ctx->position = ctx->position + ctx->longest_match;
643  GNUNET_array_append (info->contexts, info->n_contexts, new_ctx);
644 
645  /* Check whether we already have a DHT GET running for it */
646  if (GNUNET_YES ==
647  GNUNET_CONTAINER_multihashmap_contains (info->dht_get_handles, hash))
648  {
650  "GET for %s running, END\n",
651  GNUNET_h2s (hash));
653  hash,
655  new_ctx);
656  return; /* We are already looking for it */
657  }
658 
659  GNUNET_STATISTICS_update (info->stats, "# regex nodes traversed",
660  1, GNUNET_NO);
661 
663  "Following edges at %s for offset %u in `%s'\n",
664  GNUNET_h2s (hash),
665  (unsigned int) ctx->position,
666  info->description);
667  rest = &new_ctx->info->description[new_ctx->position];
668  get_h =
669  GNUNET_DHT_get_start (info->dht, /* handle */
670  GNUNET_BLOCK_TYPE_REGEX, /* type */
671  hash, /* key to search */
672  DHT_REPLICATION, /* replication level */
673  DHT_OPT,
674  rest, /* xquery */
675  strlen (rest) + 1, /* xquery bits */
676  &dht_get_string_handler, new_ctx);
677  if (GNUNET_OK !=
678  GNUNET_CONTAINER_multihashmap_put (info->dht_get_handles,
679  hash,
680  get_h,
682  {
683  GNUNET_break (0);
684  return;
685  }
686 }
static int result
Global testing status.
#define info
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
struct GNUNET_DHT_GetHandle * GNUNET_DHT_get_start(struct GNUNET_DHT_Handle *handle, enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode *key, uint32_t desired_replication_level, enum GNUNET_DHT_RouteOption options, const void *xquery, size_t xquery_size, GNUNET_DHT_GetIterator iter, void *iter_cls)
Perform an asynchronous GET operation on the DHT identified.
Definition: dht_api.c:1164
int GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_contains(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Check if the map contains any value under the given key (including values that are NULL).
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_array_append(arr, len, element)
Append an element to an array (growing the array by one).
int REGEX_BLOCK_iterate(const struct RegexBlock *block, size_t size, REGEX_INTERNAL_EgdeIterator iterator, void *iter_cls)
Iterate over all edges of a block of a regex state.
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.
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 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.
Handle to a GET request.
Definition: dht_api.c:81
Struct to keep information of searches of services described by a regex using a user-provided string ...
char * description
User provided description of the searched service.
Struct to keep state of running searches that have consumed a part of the initial string.
size_t position
Part of the description already consumed by this particular search branch.
struct REGEX_INTERNAL_Search * info
Information about the search.

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
clsClosure (search context).
expWhen will this value expire.
trunc_peertruncated peer, or NULL if none was truncated
keyKey of the result.
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.
typeType of the result.
sizeNumber of bytes in data.
dataPointer to the result data.

Definition at line 386 of file regex_internal_dht.c.

395 {
396  const struct RegexAcceptBlock *block = data;
397  struct RegexSearchContext *ctx = cls;
398  struct REGEX_INTERNAL_Search *info = ctx->info;
399 
401  "Regex result accept for %s (key %s)\n",
402  info->description, GNUNET_h2s (key));
403 
405  "# regex accepting blocks found",
406  1, GNUNET_NO);
408  "# regex accepting block bytes found",
409  size, GNUNET_NO);
410  info->callback (info->callback_cls,
411  &block->peer,
412  get_path, get_path_length,
413  put_path, put_path_length);
414 }
uint32_t data
The data value.
struct GNUNET_PeerIdentity peer
Public key of the peer signing.
Definition: block_regex.h:70

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
keyThe key of the accepting state.
ctxContext containing info about the string, tunnel, etc.

Definition at line 425 of file regex_internal_dht.c.

427 {
428  struct GNUNET_DHT_GetHandle *get_h;
429 
431  "Accept state found, now searching for paths to %s\n",
432  GNUNET_h2s (key));
433  get_h = GNUNET_DHT_get_start (ctx->info->dht, /* handle */
435  key, /* key to search */
436  DHT_REPLICATION, /* replication level */
438  NULL, /* xquery */ // FIXME BLOOMFILTER
439  0, /* xquery bits */ // FIXME BLOOMFILTER SIZE
442  GNUNET_CONTAINER_multihashmap_put (ctx->info->dht_get_handles,
443  key,
444  get_h,
446 }
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
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.

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
clsclosure (search context)
expwhen will this value expire
keykey of the result
trunc_peerNULL if not truncated
get_pathpath of the get request (not used)
get_path_lengthlength of get_path (not used)
put_pathpath of the put request (not used)
put_path_lengthlength of the put_path (not used)
typetype of the result
sizenumber of bytes in data
datapointer to the result data

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

Definition at line 468 of file regex_internal_dht.c.

477 {
478  const struct RegexBlock *block = data;
479  struct RegexSearchContext *ctx = cls;
480  struct REGEX_INTERNAL_Search *info = ctx->info;
481  size_t len;
482  struct Result *copy;
483 
485  "DHT GET result for %s (%s)\n",
486  GNUNET_h2s (key), ctx->info->description);
487  copy = GNUNET_malloc (sizeof(struct Result) + size);
488  copy->size = size;
489  copy->data = &copy[1];
490  GNUNET_memcpy (&copy[1], block, size);
492  GNUNET_CONTAINER_multihashmap_put (info->dht_get_results,
493  key, copy,
495  len = strlen (info->description);
496  if (len == ctx->position) // String processed
497  {
498  if (GNUNET_YES == GNUNET_BLOCK_is_accepting (block, size))
499  {
501  }
502  else
503  {
504  LOG (GNUNET_ERROR_TYPE_INFO, "block not accepting!\n");
505  /* FIXME REGEX this block not successful, wait for more? start timeout? */
506  }
507  return;
508  }
509  regex_next_edge (block, size, ctx);
510 }
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_malloc(size)
Wrapper around malloc.
GNUNET_NETWORK_STRUCT_END int GNUNET_BLOCK_is_accepting(const struct RegexBlock *block, size_t size)
Test if this block is marked as being an accept state.
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 regex_next_edge(const struct RegexBlock *block, size_t size, struct RegexSearchContext *ctx)
Jump to the next edge, with the longest matching token.
Type of values in dht_get_results.
const void * data
The raw result data.
size_t size
Number of bytes in data.

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
clsClosure (current context)-
keyCurrent key code (key for cached block).
valueValue in the hash map (cached RegexBlock).
Returns
GNUNET_YES: we should always continue to iterate.

Definition at line 522 of file regex_internal_dht.c.

525 {
526  struct Result *result = value;
527  const struct RegexBlock *block = result->data;
528  struct RegexSearchContext *ctx = cls;
529 
530  if ((GNUNET_YES ==
531  GNUNET_BLOCK_is_accepting (block, result->size)) &&
532  (ctx->position == strlen (ctx->info->description)))
533  {
535  "Found accepting known block\n");
537  return GNUNET_YES; // We found an accept state!
538  }
540  "* %lu, %lu, [%u]\n",
541  (unsigned long) ctx->position,
542  strlen (ctx->info->description),
543  GNUNET_BLOCK_is_accepting (block, result->size));
544  regex_next_edge (block, result->size, ctx);
545 
546  GNUNET_STATISTICS_update (ctx->info->stats, "# regex cadet blocks iterated",
547  1, GNUNET_NO);
548 
549  return GNUNET_YES;
550 }
static char * value
Value of the record to add/remove.

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
clsClosure (context of the search).
tokenToken that follows to next state.
lenLength of token.
keyHash of next state.
Returns
GNUNET_YES if should keep iterating, GNUNET_NO otherwise.

Definition at line 563 of file regex_internal_dht.c.

567 {
568  struct RegexSearchContext *ctx = cls;
569  struct REGEX_INTERNAL_Search *info = ctx->info;
570  const char *current;
571  size_t current_len;
572 
573  GNUNET_STATISTICS_update (info->stats, "# regex edges iterated",
574  1, GNUNET_NO);
575  current = &info->description[ctx->position];
576  current_len = strlen (info->description) - ctx->position;
577  if (len > current_len)
578  {
579  LOG (GNUNET_ERROR_TYPE_DEBUG, "Token too long, END\n");
580  return GNUNET_YES;
581  }
582  if (0 != strncmp (current, token, len))
583  {
584  LOG (GNUNET_ERROR_TYPE_DEBUG, "Token doesn't match, END\n");
585  return GNUNET_YES;
586  }
587 
588  if (len > ctx->longest_match)
589  {
590  LOG (GNUNET_ERROR_TYPE_DEBUG, "Token is longer, KEEP\n");
591  ctx->longest_match = len;
592  ctx->hash = *key;
593  }
594  else
595  {
596  LOG (GNUNET_ERROR_TYPE_DEBUG, "Token is not longer, IGNORE\n");
597  }
598 
599  LOG (GNUNET_ERROR_TYPE_DEBUG, "* End of regex edge iterator\n");
600  return GNUNET_YES;
601 }

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
dhtAn existing and valid DHT service handle.
stringString to match against the regexes in the DHT.
callbackCallback for found peers.
callback_clsClosure for callback.
statsOptional 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 703 of file regex_internal_dht.c.

708 {
709  struct REGEX_INTERNAL_Search *h;
710  struct GNUNET_DHT_GetHandle *get_h;
711  struct RegexSearchContext *ctx;
712  struct GNUNET_HashCode key;
713  size_t size;
714  size_t len;
715 
716  /* Initialize handle */
717  GNUNET_assert (NULL != dht);
718  GNUNET_assert (NULL != callback);
720  h->dht = dht;
721  h->description = GNUNET_strdup (string);
722  h->callback = callback;
723  h->callback_cls = callback_cls;
724  h->stats = stats;
725  h->dht_get_handles = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
726  h->dht_get_results = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
727 
728  /* Initialize context */
729  len = strlen (string);
732  "Initial key for `%s' is %s (based on `%.*s')\n",
733  string,
734  GNUNET_h2s (&key),
735  (int) size,
736  string);
737  ctx = GNUNET_new (struct RegexSearchContext);
738  ctx->position = size;
739  ctx->info = h;
740  GNUNET_array_append (h->contexts,
741  h->n_contexts,
742  ctx);
743  /* Start search in DHT */
744  get_h = GNUNET_DHT_get_start (h->dht, /* handle */
745  GNUNET_BLOCK_TYPE_REGEX, /* type */
746  &key, /* key to search */
747  DHT_REPLICATION, /* replication level */
748  DHT_OPT,
749  &h->description[size], /* xquery */
750  // FIXME add BLOOMFILTER to exclude filtered peers
751  len + 1 - size, /* xquery bits */
752  // FIXME add BLOOMFILTER SIZE
754  GNUNET_break (
755  GNUNET_OK ==
756  GNUNET_CONTAINER_multihashmap_put (h->dht_get_handles,
757  &key,
758  get_h,
760  );
761 
762  return h;
763 }
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
size_t REGEX_INTERNAL_get_first_key(const char *input_string, size_t string_len, struct GNUNET_HashCode *key)
Get the first key for the given input_string.

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
clsClosure (unused).
keyCurrent key code (unused).
valueValue in the hash map (get handle).
Returns
GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 777 of file regex_internal_dht.c.

780 {
781  struct GNUNET_DHT_GetHandle *h = value;
782 
784  return GNUNET_YES;
785 }
void GNUNET_DHT_get_stop(struct GNUNET_DHT_GetHandle *get_handle)
Stop async DHT-get.
Definition: dht_api.c:1237

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
clsClosure (unused).
keyCurrent key code (unused).
valueCadetRegexBlock in the hash map.
Returns
GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 799 of file regex_internal_dht.c.

802 {
803  GNUNET_free (value);
804  return GNUNET_YES;
805 }

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
hthe search context.

Definition at line 814 of file regex_internal_dht.c.

815 {
816  unsigned int i;
817 
818  GNUNET_free (h->description);
819  GNUNET_CONTAINER_multihashmap_iterate (h->dht_get_handles,
820  &regex_cancel_dht_get, NULL);
821  GNUNET_CONTAINER_multihashmap_iterate (h->dht_get_results,
822  &regex_free_result, NULL);
823  GNUNET_CONTAINER_multihashmap_destroy (h->dht_get_results);
824  GNUNET_CONTAINER_multihashmap_destroy (h->dht_get_handles);
825  if (0 < h->n_contexts)
826  {
827  for (i = 0; i < h->n_contexts; i++)
828  GNUNET_free (h->contexts[i]);
829  GNUNET_free (h->contexts);
830  }
831  GNUNET_free (h);
832 }
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
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_strin...

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: