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.
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.
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:986
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.
#define GNUNET_NO
Definition: gnunet_common.h:78
void REGEX_INTERNAL_announce_cancel(struct REGEX_INTERNAL_Announcement *h)
Clear all cached data used by a regex announce.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
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:270
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.
#define GNUNET_array_append(arr, size, element)
Append an element to a list (growing the list by one).
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;.
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.
#define GNUNET_YES
Definition: gnunet_common.h:77
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. ...