GNUnet  0.11.x
regex_internal_dht.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2012, 2015 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
26 #include "platform.h"
27 #include "regex_internal_lib.h"
28 #include "regex_block_lib.h"
29 #include "gnunet_dht_service.h"
31 #include "gnunet_constants.h"
32 #include "gnunet_signatures.h"
33 
34 
35 #define LOG(kind, ...) GNUNET_log_from (kind, "regex-dht", __VA_ARGS__)
36 
40 #define DHT_REPLICATION 5
41 
45 #define DHT_TTL GNUNET_TIME_UNIT_HOURS
46 
50 #define DHT_OPT GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE
51 
52 
57 {
62 
66  const char *regex;
67 
72 
77 
82 };
83 
84 
95 static void
96 regex_iterator (void *cls,
97  const struct GNUNET_HashCode *key,
98  const char *proof,
99  int accepting,
100  unsigned int num_edges,
101  const struct REGEX_BLOCK_Edge *edges)
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));
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);
175  "# regex blocks stored",
176  1,
177  GNUNET_NO);
179  "# regex block bytes stored",
180  size,
181  GNUNET_NO);
182  GNUNET_free (block);
183 }
184 
185 
200  const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
201  const char *regex,
202  uint16_t compression,
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 }
217 
218 
225 void
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 }
236 
237 
244 void
246 {
248  GNUNET_free (h);
249 }
250 
251 
252 /******************************************************************************/
253 
254 
260 {
265  size_t position;
266 
271 
276  unsigned int longest_match;
277 
281  struct GNUNET_HashCode hash;
282 };
283 
284 
288 struct Result
289 {
293  size_t size;
294 
298  const void *data;
299 };
300 
301 
307 {
312 
317 
321  char *description;
322 
327 
333 
338 
342  unsigned int n_contexts;
343 
348 
353 };
354 
355 
363 static void
364 regex_next_edge (const struct RegexBlock *block,
365  size_t size,
366  struct RegexSearchContext *ctx);
367 
368 
384 static void
386  const struct GNUNET_HashCode *key,
387  const struct GNUNET_PeerIdentity *get_path,
388  unsigned int get_path_length,
389  const struct GNUNET_PeerIdentity *put_path,
390  unsigned int put_path_length,
391  enum GNUNET_BLOCK_Type type,
392  size_t size, const void *data)
393 {
394  const struct RegexAcceptBlock *block = data;
395  struct RegexSearchContext *ctx = cls;
396  struct REGEX_INTERNAL_Search *info = ctx->info;
397 
399  "Regex result accept for %s (key %s)\n",
400  info->description, GNUNET_h2s (key));
401 
403  "# regex accepting blocks found",
404  1, GNUNET_NO);
406  "# regex accepting block bytes found",
407  size, GNUNET_NO);
408  info->callback (info->callback_cls,
409  &block->peer,
410  get_path, get_path_length,
411  put_path, put_path_length);
412 }
413 
414 
422 static void
424  struct RegexSearchContext *ctx)
425 {
426  struct GNUNET_DHT_GetHandle *get_h;
427 
429  "Accept state found, now searching for paths to %s\n",
430  GNUNET_h2s (key),
431  (unsigned int) ctx->position);
432  get_h = GNUNET_DHT_get_start (ctx->info->dht, /* handle */
434  key, /* key to search */
435  DHT_REPLICATION, /* replication level */
437  NULL, /* xquery */ // FIXME BLOOMFILTER
438  0, /* xquery bits */ // FIXME BLOOMFILTER SIZE
442  key,
443  get_h,
445 }
446 
447 
465 static void
467  const struct GNUNET_HashCode *key,
468  const struct GNUNET_PeerIdentity *get_path,
469  unsigned int get_path_length,
470  const struct GNUNET_PeerIdentity *put_path,
471  unsigned int put_path_length,
472  enum GNUNET_BLOCK_Type type,
473  size_t size, const void *data)
474 {
475  const struct RegexBlock *block = data;
476  struct RegexSearchContext *ctx = cls;
477  struct REGEX_INTERNAL_Search *info = ctx->info;
478  size_t len;
479  struct Result *copy;
480 
482  "DHT GET result for %s (%s)\n",
483  GNUNET_h2s (key), ctx->info->description);
484  copy = GNUNET_malloc (sizeof(struct Result) + size);
485  copy->size = size;
486  copy->data = &copy[1];
487  GNUNET_memcpy (&copy[1], block, size);
490  key, copy,
492  len = strlen (info->description);
493  if (len == ctx->position) // String processed
494  {
495  if (GNUNET_YES == GNUNET_BLOCK_is_accepting (block, size))
496  {
497  regex_find_path (key, ctx);
498  }
499  else
500  {
501  LOG (GNUNET_ERROR_TYPE_INFO, "block not accepting!\n");
502  /* FIXME REGEX this block not successful, wait for more? start timeout? */
503  }
504  return;
505  }
506  regex_next_edge (block, size, ctx);
507 }
508 
509 
518 static int
520  const struct GNUNET_HashCode *key,
521  void *value)
522 {
523  struct Result *result = value;
524  const struct RegexBlock *block = result->data;
525  struct RegexSearchContext *ctx = cls;
526 
527  if ((GNUNET_YES ==
528  GNUNET_BLOCK_is_accepting (block, result->size)) &&
529  (ctx->position == strlen (ctx->info->description)))
530  {
532  "Found accepting known block\n");
533  regex_find_path (key, ctx);
534  return GNUNET_YES; // We found an accept state!
535  }
537  "* %u, %u, [%u]\n",
538  ctx->position,
539  strlen (ctx->info->description),
540  GNUNET_BLOCK_is_accepting (block, result->size));
541  regex_next_edge (block, result->size, ctx);
542 
543  GNUNET_STATISTICS_update (ctx->info->stats, "# regex cadet blocks iterated",
544  1, GNUNET_NO);
545 
546  return GNUNET_YES;
547 }
548 
549 
559 static int
561  const char *token,
562  size_t len,
563  const struct GNUNET_HashCode *key)
564 {
565  struct RegexSearchContext *ctx = cls;
566  struct REGEX_INTERNAL_Search *info = ctx->info;
567  const char *current;
568  size_t current_len;
569 
570  GNUNET_STATISTICS_update (info->stats, "# regex edges iterated",
571  1, GNUNET_NO);
572  current = &info->description[ctx->position];
573  current_len = strlen (info->description) - ctx->position;
574  if (len > current_len)
575  {
576  LOG (GNUNET_ERROR_TYPE_DEBUG, "Token too long, END\n");
577  return GNUNET_YES;
578  }
579  if (0 != strncmp (current, token, len))
580  {
581  LOG (GNUNET_ERROR_TYPE_DEBUG, "Token doesn't match, END\n");
582  return GNUNET_YES;
583  }
584 
585  if (len > ctx->longest_match)
586  {
587  LOG (GNUNET_ERROR_TYPE_DEBUG, "Token is longer, KEEP\n");
588  ctx->longest_match = len;
589  ctx->hash = *key;
590  }
591  else
592  {
593  LOG (GNUNET_ERROR_TYPE_DEBUG, "Token is not longer, IGNORE\n");
594  }
595 
596  LOG (GNUNET_ERROR_TYPE_DEBUG, "* End of regex edge iterator\n");
597  return GNUNET_YES;
598 }
599 
600 
608 static void
609 regex_next_edge (const struct RegexBlock *block,
610  size_t size,
611  struct RegexSearchContext *ctx)
612 {
613  struct RegexSearchContext *new_ctx;
614  struct REGEX_INTERNAL_Search *info = ctx->info;
615  struct GNUNET_DHT_GetHandle *get_h;
616  struct GNUNET_HashCode *hash;
617  const char *rest;
618  int result;
619 
620  LOG (GNUNET_ERROR_TYPE_DEBUG, "Next edge\n");
621  /* Find the longest match for the current string position,
622  * among tokens in the given block */
623  ctx->longest_match = 0;
624  result = REGEX_BLOCK_iterate (block, size,
625  &regex_edge_iterator, ctx);
626  GNUNET_break (GNUNET_OK == result);
627 
628  /* Did anything match? */
629  if (0 == ctx->longest_match)
630  {
632  "no match in block\n");
633  return;
634  }
635 
636  hash = &ctx->hash;
637  new_ctx = GNUNET_new (struct RegexSearchContext);
638  new_ctx->info = info;
639  new_ctx->position = ctx->position + ctx->longest_match;
640  GNUNET_array_append (info->contexts, info->n_contexts, new_ctx);
641 
642  /* Check whether we already have a DHT GET running for it */
643  if (GNUNET_YES ==
645  {
647  "GET for %s running, END\n",
648  GNUNET_h2s (hash));
650  hash,
652  new_ctx);
653  return; /* We are already looking for it */
654  }
655 
656  GNUNET_STATISTICS_update (info->stats, "# regex nodes traversed",
657  1, GNUNET_NO);
658 
660  "Following edges at %s for offset %u in `%s'\n",
661  GNUNET_h2s (hash),
662  (unsigned int) ctx->position,
663  info->description);
664  rest = &new_ctx->info->description[new_ctx->position];
665  get_h =
666  GNUNET_DHT_get_start (info->dht, /* handle */
667  GNUNET_BLOCK_TYPE_REGEX, /* type */
668  hash, /* key to search */
669  DHT_REPLICATION, /* replication level */
670  DHT_OPT,
671  rest, /* xquery */
672  strlen (rest) + 1, /* xquery bits */
673  &dht_get_string_handler, new_ctx);
674  if (GNUNET_OK !=
676  hash,
677  get_h,
679  {
680  GNUNET_break (0);
681  return;
682  }
683 }
684 
685 
699 struct REGEX_INTERNAL_Search *
701  const char *string,
703  void *callback_cls,
705 {
706  struct REGEX_INTERNAL_Search *h;
707  struct GNUNET_DHT_GetHandle *get_h;
708  struct RegexSearchContext *ctx;
709  struct GNUNET_HashCode key;
710  size_t size;
711  size_t len;
712 
713  /* Initialize handle */
714  GNUNET_assert (NULL != dht);
715  GNUNET_assert (NULL != callback);
716  h = GNUNET_new (struct REGEX_INTERNAL_Search);
717  h->dht = dht;
718  h->description = GNUNET_strdup (string);
719  h->callback = callback;
720  h->callback_cls = callback_cls;
721  h->stats = stats;
724 
725  /* Initialize context */
726  len = strlen (string);
727  size = REGEX_INTERNAL_get_first_key (string, len, &key);
729  "Initial key for `%s' is %s (based on `%.*s')\n",
730  string,
731  GNUNET_h2s (&key),
732  size,
733  string);
734  ctx = GNUNET_new (struct RegexSearchContext);
735  ctx->position = size;
736  ctx->info = h;
738  h->n_contexts,
739  ctx);
740  /* Start search in DHT */
741  get_h = GNUNET_DHT_get_start (h->dht, /* handle */
742  GNUNET_BLOCK_TYPE_REGEX, /* type */
743  &key, /* key to search */
744  DHT_REPLICATION, /* replication level */
745  DHT_OPT,
746  &h->description[size], /* xquery */
747  // FIXME add BLOOMFILTER to exclude filtered peers
748  len + 1 - size, /* xquery bits */
749  // FIXME add BLOOMFILTER SIZE
750  &dht_get_string_handler, ctx);
751  GNUNET_break (
752  GNUNET_OK ==
754  &key,
755  get_h,
757  );
758 
759  return h;
760 }
761 
762 
773 static int
775  const struct GNUNET_HashCode *key,
776  void *value)
777 {
778  struct GNUNET_DHT_GetHandle *h = value;
779 
781  return GNUNET_YES;
782 }
783 
784 
795 static int
796 regex_free_result (void *cls,
797  const struct GNUNET_HashCode *key,
798  void *value)
799 {
800  GNUNET_free (value);
801  return GNUNET_YES;
802 }
803 
804 
810 void
812 {
813  unsigned int i;
814 
817  &regex_cancel_dht_get, NULL);
819  &regex_free_result, NULL);
822  if (0 < h->n_contexts)
823  {
824  for (i = 0; i < h->n_contexts; i++)
825  GNUNET_free (h->contexts[i]);
826  GNUNET_free (h->contexts);
827  }
828  GNUNET_free (h);
829 }
830 
831 
832 /* end of regex_internal_dht.c */
#define GNUNET_CONSTANTS_DHT_MAX_EXPIRATION
How long do we cache records at most in the DHT?
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.
Block to store a cadet regex accepting state.
#define DHT_REPLICATION
DHT replication level to use.
const void * data
The raw result data.
We should keep track of the route that the message took in the P2P network.
size_t position
Part of the description already consumed by this particular search branch.
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.
static void dht_get_string_accept_handler(void *cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const struct GNUNET_PeerIdentity *get_path, unsigned int get_path_length, const struct GNUNET_PeerIdentity *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.
#define GNUNET_array_append(arr, len, element)
Append an element to an array (growing the array by one).
struct GNUNET_HashCode key
The key of the state.
Definition: block_regex.h:65
uint16_t num_edges
Number of edges parting from this state.
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...
GNUNET_BLOCK_Type
Blocks in the datastore and the datacache must have a unique type.
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:246
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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.
struct GNUNET_CRYPTO_EddsaSignature signature
The signature.
Definition: block_regex.h:75
Block to announce a regex state.
Struct to keep state of running searches that have consumed a part of the inital string.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
void REGEX_INTERNAL_announce_cancel(struct REGEX_INTERNAL_Announcement *h)
Clear all cached data used by a regex announce.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Automaton representation.
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...
int 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)...
Block to announce a peer accepting a state.
Definition: block_regex.h:49
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
Handle for the service.
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.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
Time for absolute time used by GNUnet, in microseconds and in network byte order. ...
#define DHT_OPT
DHT options to set.
Internal representation of the hash map.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Edge representation.
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
Connection to the DHT service.
Definition: dht_api.c:201
struct GNUNET_PeerIdentity peer
Public key of the peer signing.
Definition: block_regex.h:70
header of what an ECC signature signs this must be followed by "size - 8" bytes of the actual signed ...
struct GNUNET_HashCode hash
Destination hash of the longest match.
static void dht_get_string_handler(void *cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const struct GNUNET_PeerIdentity *get_path, unsigned int get_path_length, const struct GNUNET_PeerIdentity *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.
#define DHT_TTL
DHT record lifetime to use.
, &#39; bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_...
static char * value
Value of the record to add/remove.
library to parse regular expressions into dfa
static uint64_t proof
Definition: gnunet-scrypt.c:41
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.
struct REGEX_INTERNAL_Search * info
Information about the search.
static int result
Global testing status.
Handle to store cached data about a regex announce.
void REGEX_INTERNAL_search_cancel(struct REGEX_INTERNAL_Search *h)
Cancel an ongoing regex search in the DHT and free all resources.
uint32_t size
How many bytes does this signature sign? (including this purpose header); in network byte order (!)...
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Accept blocks must be signed.
Definition: block_regex.h:55
A 512-bit hashcode.
void GNUNET_DHT_get_stop(struct GNUNET_DHT_GetHandle *get_handle)
Stop async DHT-get.
Definition: dht_api.c:1155
Type of values in dht_get_results.
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.
struct GNUNET_CONTAINER_MultiHashMap * dht_get_results
Results from running DHT GETs, values are of type &#39;struct Result&#39;.
void(* REGEX_INTERNAL_Found)(void *cls, const struct GNUNET_PeerIdentity *id, const struct GNUNET_PeerIdentity *get_path, unsigned int get_path_length, const struct GNUNET_PeerIdentity *put_path, unsigned int put_path_length)
Search callback function.
struct GNUNET_HashCode key
The key used in the DHT.
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:966
static unsigned int size
Size of the "table".
Definition: peer.c:67
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.
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.
struct GNUNET_DHT_Handle * dht
DHT handle to use, must be initialized externally.
unsigned int n_contexts
Number of contexts (branches/steps in search).
void REGEX_INTERNAL_automaton_destroy(struct REGEX_INTERNAL_Automaton *a)
Free the memory allocated by constructing the REGEX_INTERNAL_Automaton data structure.
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.
int 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.
Handle to a GET request.
Definition: dht_api.c:79
struct GNUNET_STATISTICS_Handle * stats
Optional statistics handle to report usage.
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:193
Struct to keep information of searches of services described by a regex using a user-provided string ...
void REGEX_INTERNAL_reannounce(struct REGEX_INTERNAL_Announcement *h)
Announce again a regular expression previously announced.
Allow multiple values with the same key.
Private ECC key encoded for transmission.
The identity of the host (wraps the signing key of the peer).
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.
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:1067
#define GNUNET_SIGNATURE_PURPOSE_REGEX_ACCEPT
Accept state in regex DFA.
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 &#39;regex&#39; of length &#39;len&#39;.
int 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:707
common function to manipulate blocks stored by regex in the DHT
char * description
User provided description of the searched service.
REGEX_INTERNAL_Found callback
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
const char * regex
Regular expression.
Time for absolute times used by GNUnet, in microseconds.
struct GNUNET_STATISTICS_Handle * stats
Optional statistics handle to report usage.
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.
#define LOG(kind,...)
struct GNUNET_DHT_Handle * dht
DHT handle to use, must be initialized externally.
void REGEX_INTERNAL_iterate_reachable_edges(struct REGEX_INTERNAL_Automaton *a, REGEX_INTERNAL_KeyIterator iterator, void *iterator_cls)
Iterate over all edges of automaton &#39;a&#39; that are reachable from a state with a proof of at least GNUN...
const struct GNUNET_CRYPTO_EddsaPrivateKey * priv
Our private key.
Block to store a cadet regex state.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
uint32_t data
The data value.
struct GNUNET_CONTAINER_MultiHashMap * dht_get_handles
Running DHT GETs.
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:657
struct REGEX_INTERNAL_Automaton * dfa
Automaton representation of the regex (expensive to build).
#define GNUNET_malloc(size)
Wrapper around malloc.
unsigned int longest_match
We just want to look for one edge, the longer the better.
struct RegexSearchContext ** contexts
Contexts, for each running DHT GET.
#define GNUNET_free(ptr)
Wrapper around free.
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.
struct GNUNET_CRYPTO_EddsaPublicKey public_key
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
size_t size
Number of bytes in data.
struct GNUNET_TIME_AbsoluteNBO expiration_time
When does the signature expire?
Definition: block_regex.h:60
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. ...