GNUnet  0.19.2
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);
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 }
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 
219 void
221 {
222  GNUNET_assert (NULL != h->dfa); /* make sure to call announce first */
224  "REGEX_INTERNAL_reannounce: %s\n",
225  h->regex);
228  h);
229 }
230 
231 
238 void
240 {
242  GNUNET_free (h);
243 }
244 
245 
246 /******************************************************************************/
247 
248 
254 {
259  size_t position;
260 
265 
270  unsigned int longest_match;
271 
275  struct GNUNET_HashCode hash;
276 };
277 
278 
282 struct Result
283 {
287  size_t size;
288 
292  const void *data;
293 };
294 
295 
301 {
306 
311 
315  char *description;
316 
321 
327 
332 
336  unsigned int n_contexts;
337 
342 
347 };
348 
349 
357 static void
358 regex_next_edge (const struct RegexBlock *block,
359  size_t size,
360  struct RegexSearchContext *ctx);
361 
362 
379 static void
381  const struct GNUNET_HashCode *key,
382  const struct GNUNET_PeerIdentity *trunc_peer,
383  const struct GNUNET_DHT_PathElement *get_path,
384  unsigned int get_path_length,
385  const struct GNUNET_DHT_PathElement *put_path,
386  unsigned int put_path_length,
387  enum GNUNET_BLOCK_Type type,
388  size_t size, const void *data)
389 {
390  const struct RegexAcceptBlock *block = data;
391  struct RegexSearchContext *ctx = cls;
392  struct REGEX_INTERNAL_Search *info = ctx->info;
393 
395  "Regex result accept for %s (key %s)\n",
396  info->description, GNUNET_h2s (key));
397 
399  "# regex accepting blocks found",
400  1, GNUNET_NO);
402  "# regex accepting block bytes found",
403  size, GNUNET_NO);
404  info->callback (info->callback_cls,
405  &block->peer,
406  get_path, get_path_length,
407  put_path, put_path_length);
408 }
409 
410 
418 static void
420  struct RegexSearchContext *ctx)
421 {
422  struct GNUNET_DHT_GetHandle *get_h;
423 
425  "Accept state found, now searching for paths to %s\n",
426  GNUNET_h2s (key));
427  get_h = GNUNET_DHT_get_start (ctx->info->dht, /* handle */
429  key, /* key to search */
430  DHT_REPLICATION, /* replication level */
432  NULL, /* xquery */ // FIXME BLOOMFILTER
433  0, /* xquery bits */ // FIXME BLOOMFILTER SIZE
436  GNUNET_CONTAINER_multihashmap_put (ctx->info->dht_get_handles,
437  key,
438  get_h,
440 }
441 
442 
461 static void
463  const struct GNUNET_HashCode *key,
464  const struct GNUNET_PeerIdentity *trunc_peer,
465  const struct GNUNET_DHT_PathElement *get_path,
466  unsigned int get_path_length,
467  const struct GNUNET_DHT_PathElement *put_path,
468  unsigned int put_path_length,
469  enum GNUNET_BLOCK_Type type,
470  size_t size, const void *data)
471 {
472  const struct RegexBlock *block = data;
473  struct RegexSearchContext *ctx = cls;
474  struct REGEX_INTERNAL_Search *info = ctx->info;
475  size_t len;
476  struct Result *copy;
477 
479  "DHT GET result for %s (%s)\n",
480  GNUNET_h2s (key), ctx->info->description);
481  copy = GNUNET_malloc (sizeof(struct Result) + size);
482  copy->size = size;
483  copy->data = &copy[1];
484  GNUNET_memcpy (&copy[1], block, size);
486  GNUNET_CONTAINER_multihashmap_put (info->dht_get_results,
487  key, copy,
489  len = strlen (info->description);
490  if (len == ctx->position) // String processed
491  {
492  if (GNUNET_YES == GNUNET_BLOCK_is_accepting (block, size))
493  {
495  }
496  else
497  {
498  LOG (GNUNET_ERROR_TYPE_INFO, "block not accepting!\n");
499  /* FIXME REGEX this block not successful, wait for more? start timeout? */
500  }
501  return;
502  }
503  regex_next_edge (block, size, ctx);
504 }
505 
506 
515 static int
517  const struct GNUNET_HashCode *key,
518  void *value)
519 {
520  struct Result *result = value;
521  const struct RegexBlock *block = result->data;
522  struct RegexSearchContext *ctx = cls;
523 
524  if ((GNUNET_YES ==
525  GNUNET_BLOCK_is_accepting (block, result->size)) &&
526  (ctx->position == strlen (ctx->info->description)))
527  {
529  "Found accepting known block\n");
531  return GNUNET_YES; // We found an accept state!
532  }
534  "* %lu, %lu, [%u]\n",
535  (unsigned long) ctx->position,
536  strlen (ctx->info->description),
537  GNUNET_BLOCK_is_accepting (block, result->size));
538  regex_next_edge (block, result->size, ctx);
539 
540  GNUNET_STATISTICS_update (ctx->info->stats, "# regex cadet blocks iterated",
541  1, GNUNET_NO);
542 
543  return GNUNET_YES;
544 }
545 
546 
556 static int
558  const char *token,
559  size_t len,
560  const struct GNUNET_HashCode *key)
561 {
562  struct RegexSearchContext *ctx = cls;
563  struct REGEX_INTERNAL_Search *info = ctx->info;
564  const char *current;
565  size_t current_len;
566 
567  GNUNET_STATISTICS_update (info->stats, "# regex edges iterated",
568  1, GNUNET_NO);
569  current = &info->description[ctx->position];
570  current_len = strlen (info->description) - ctx->position;
571  if (len > current_len)
572  {
573  LOG (GNUNET_ERROR_TYPE_DEBUG, "Token too long, END\n");
574  return GNUNET_YES;
575  }
576  if (0 != strncmp (current, token, len))
577  {
578  LOG (GNUNET_ERROR_TYPE_DEBUG, "Token doesn't match, END\n");
579  return GNUNET_YES;
580  }
581 
582  if (len > ctx->longest_match)
583  {
584  LOG (GNUNET_ERROR_TYPE_DEBUG, "Token is longer, KEEP\n");
585  ctx->longest_match = len;
586  ctx->hash = *key;
587  }
588  else
589  {
590  LOG (GNUNET_ERROR_TYPE_DEBUG, "Token is not longer, IGNORE\n");
591  }
592 
593  LOG (GNUNET_ERROR_TYPE_DEBUG, "* End of regex edge iterator\n");
594  return GNUNET_YES;
595 }
596 
597 
605 static void
606 regex_next_edge (const struct RegexBlock *block,
607  size_t size,
608  struct RegexSearchContext *ctx)
609 {
610  struct RegexSearchContext *new_ctx;
611  struct REGEX_INTERNAL_Search *info = ctx->info;
612  struct GNUNET_DHT_GetHandle *get_h;
613  struct GNUNET_HashCode *hash;
614  const char *rest;
615  int result;
616 
617  LOG (GNUNET_ERROR_TYPE_DEBUG, "Next edge\n");
618  /* Find the longest match for the current string position,
619  * among tokens in the given block */
620  ctx->longest_match = 0;
621  result = REGEX_BLOCK_iterate (block, size,
624 
625  /* Did anything match? */
626  if (0 == ctx->longest_match)
627  {
629  "no match in block\n");
630  return;
631  }
632 
633  hash = &ctx->hash;
634  new_ctx = GNUNET_new (struct RegexSearchContext);
635  new_ctx->info = info;
636  new_ctx->position = ctx->position + ctx->longest_match;
637  GNUNET_array_append (info->contexts, info->n_contexts, new_ctx);
638 
639  /* Check whether we already have a DHT GET running for it */
640  if (GNUNET_YES ==
641  GNUNET_CONTAINER_multihashmap_contains (info->dht_get_handles, hash))
642  {
644  "GET for %s running, END\n",
645  GNUNET_h2s (hash));
647  hash,
649  new_ctx);
650  return; /* We are already looking for it */
651  }
652 
653  GNUNET_STATISTICS_update (info->stats, "# regex nodes traversed",
654  1, GNUNET_NO);
655 
657  "Following edges at %s for offset %u in `%s'\n",
658  GNUNET_h2s (hash),
659  (unsigned int) ctx->position,
660  info->description);
661  rest = &new_ctx->info->description[new_ctx->position];
662  get_h =
663  GNUNET_DHT_get_start (info->dht, /* handle */
664  GNUNET_BLOCK_TYPE_REGEX, /* type */
665  hash, /* key to search */
666  DHT_REPLICATION, /* replication level */
667  DHT_OPT,
668  rest, /* xquery */
669  strlen (rest) + 1, /* xquery bits */
670  &dht_get_string_handler, new_ctx);
671  if (GNUNET_OK !=
672  GNUNET_CONTAINER_multihashmap_put (info->dht_get_handles,
673  hash,
674  get_h,
676  {
677  GNUNET_break (0);
678  return;
679  }
680 }
681 
682 
696 struct REGEX_INTERNAL_Search *
698  const char *string,
700  void *callback_cls,
702 {
703  struct REGEX_INTERNAL_Search *h;
704  struct GNUNET_DHT_GetHandle *get_h;
705  struct RegexSearchContext *ctx;
706  struct GNUNET_HashCode key;
707  size_t size;
708  size_t len;
709 
710  /* Initialize handle */
711  GNUNET_assert (NULL != dht);
712  GNUNET_assert (NULL != callback);
714  h->dht = dht;
715  h->description = GNUNET_strdup (string);
716  h->callback = callback;
717  h->callback_cls = callback_cls;
718  h->stats = stats;
719  h->dht_get_handles = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
720  h->dht_get_results = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
721 
722  /* Initialize context */
723  len = strlen (string);
726  "Initial key for `%s' is %s (based on `%.*s')\n",
727  string,
728  GNUNET_h2s (&key),
729  (int) size,
730  string);
731  ctx = GNUNET_new (struct RegexSearchContext);
732  ctx->position = size;
733  ctx->info = h;
734  GNUNET_array_append (h->contexts,
735  h->n_contexts,
736  ctx);
737  /* Start search in DHT */
738  get_h = GNUNET_DHT_get_start (h->dht, /* handle */
739  GNUNET_BLOCK_TYPE_REGEX, /* type */
740  &key, /* key to search */
741  DHT_REPLICATION, /* replication level */
742  DHT_OPT,
743  &h->description[size], /* xquery */
744  // FIXME add BLOOMFILTER to exclude filtered peers
745  len + 1 - size, /* xquery bits */
746  // FIXME add BLOOMFILTER SIZE
748  GNUNET_break (
749  GNUNET_OK ==
750  GNUNET_CONTAINER_multihashmap_put (h->dht_get_handles,
751  &key,
752  get_h,
754  );
755 
756  return h;
757 }
758 
759 
770 static int
772  const struct GNUNET_HashCode *key,
773  void *value)
774 {
775  struct GNUNET_DHT_GetHandle *h = value;
776 
778  return GNUNET_YES;
779 }
780 
781 
792 static int
793 regex_free_result (void *cls,
794  const struct GNUNET_HashCode *key,
795  void *value)
796 {
797  GNUNET_free (value);
798  return GNUNET_YES;
799 }
800 
801 
807 void
809 {
810  unsigned int i;
811 
812  GNUNET_free (h->description);
813  GNUNET_CONTAINER_multihashmap_iterate (h->dht_get_handles,
814  &regex_cancel_dht_get, NULL);
815  GNUNET_CONTAINER_multihashmap_iterate (h->dht_get_results,
816  &regex_free_result, NULL);
817  GNUNET_CONTAINER_multihashmap_destroy (h->dht_get_results);
818  GNUNET_CONTAINER_multihashmap_destroy (h->dht_get_handles);
819  if (0 < h->n_contexts)
820  {
821  for (i = 0; i < h->n_contexts; i++)
822  GNUNET_free (h->contexts[i]);
823  GNUNET_free (h->contexts);
824  }
825  GNUNET_free (h);
826 }
827 
828 
829 /* end of regex_internal_dht.c */
GNUNET_BLOCK_Type
WARNING: This header is generated! In order to add DHT block types, you must register them in GANA,...
@ 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
static struct GNUNET_DHT_Handle * dht
Handle to the DHT.
struct GNUNET_HashCode key
The key used in the DHT.
uint32_t data
The data value.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
static char * value
Value of the record to add/remove.
static int result
Global testing status.
static uint64_t proof
Definition: gnunet-scrypt.c:49
#define info
struct GNUNET_STATISTICS_Handle * stats
Handle to the statistics service.
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
API to the DHT service.
API to create, modify and access statistics.
#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
void GNUNET_DHT_get_stop(struct GNUNET_DHT_GetHandle *get_handle)
Stop async DHT-get.
Definition: dht_api.c:1237
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
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
@ GNUNET_DHT_RO_RECORD_ROUTE
We should keep track of the route that the message took in the P2P network.
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.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
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.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_array_append(arr, len, element)
Append an element to an array (growing the array by one).
#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:316
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:638
static unsigned int size
Size of the "table".
Definition: peer.c:68
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.
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.
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.
common function to manipulate blocks stored by regex in the DHT
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.
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...
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_automaton_destroy(struct REGEX_INTERNAL_Automaton *a)
Free the memory allocated by constructing the REGEX_INTERNAL_Automaton.
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.
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.
#define DHT_TTL
DHT record lifetime to use.
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.
void REGEX_INTERNAL_search_cancel(struct REGEX_INTERNAL_Search *h)
Cancel an ongoing regex search in the DHT and free all resources.
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_accept_handler(void *cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const struct GNUNET_PeerIdentity *trunc_peer, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_length, enum GNUNET_BLOCK_Type type, size_t size, const void *data)
Function to process DHT string to regex matching.
static 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 void regex_find_path(const struct GNUNET_HashCode *key, struct RegexSearchContext *ctx)
Find a path to a peer that offers a regex service compatible with a given string.
static void dht_get_string_handler(void *cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const struct GNUNET_PeerIdentity *trunc_peer, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_length, enum GNUNET_BLOCK_Type type, size_t size, const void *data)
Function to process DHT string to regex matching.
static void regex_next_edge(const struct RegexBlock *block, size_t size, struct RegexSearchContext *ctx)
Jump to the next edge, with the longest matching token.
void REGEX_INTERNAL_announce_cancel(struct REGEX_INTERNAL_Announcement *h)
Clear all cached data used by a regex announce.
void REGEX_INTERNAL_reannounce(struct REGEX_INTERNAL_Announcement *h)
Announce again a regular expression previously announced.
#define DHT_REPLICATION
DHT replication level to use.
#define LOG(kind,...)
#define DHT_OPT
DHT options to set.
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...
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.
library to parse regular expressions into dfa
void(* REGEX_INTERNAL_Found)(void *cls, const struct GNUNET_PeerIdentity *id, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_length)
Search callback function.
Internal representation of the hash map.
header of what an ECC signature signs this must be followed by "size - 8" bytes of the actual signed ...
uint32_t size
How many bytes does this signature sign? (including this purpose header); in network byte order (!...
uint32_t purpose
What does this signature vouch for? This must contain a GNUNET_SIGNATURE_PURPOSE_XXX constant (from g...
Private ECC key encoded for transmission.
Handle to a GET request.
Definition: dht_api.c:81
Connection to the DHT service.
Definition: dht_api.c:237
A (signed) path tracking a block's flow through the DHT is represented by an array of path elements,...
A 512-bit hashcode.
The identity of the host (wraps the signing key of the peer).
struct GNUNET_CRYPTO_EddsaPublicKey public_key
Handle for the service.
Time for absolute time used by GNUnet, in microseconds and in network byte order.
Time for absolute times used by GNUnet, in microseconds.
Edge representation.
Handle to store cached data about a regex announce.
struct REGEX_INTERNAL_Automaton * dfa
Automaton representation of the regex (expensive to build).
struct GNUNET_DHT_Handle * dht
DHT handle to use, must be initialized externally.
const struct GNUNET_CRYPTO_EddsaPrivateKey * priv
Our private key.
struct GNUNET_STATISTICS_Handle * stats
Optional statistics handle to report usage.
const char * regex
Regular expression.
Automaton representation.
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 RegexSearchContext ** contexts
Contexts, for each running DHT GET.
struct GNUNET_CONTAINER_MultiHashMap * dht_get_results
Results from running DHT GETs, values are of type 'struct Result'.
struct GNUNET_CONTAINER_MultiHashMap * dht_get_handles
Running DHT GETs.
struct GNUNET_DHT_Handle * dht
DHT handle to use, must be initialized externally.
struct GNUNET_STATISTICS_Handle * stats
Optional statistics handle to report usage.
unsigned int n_contexts
Number of contexts (branches/steps in search).
REGEX_INTERNAL_Found callback
Block to announce a peer accepting a state.
Definition: block_regex.h:51
struct GNUNET_HashCode key
The key of the state.
Definition: block_regex.h:66
struct GNUNET_TIME_AbsoluteNBO expiration_time
When does the signature expire?
Definition: block_regex.h:61
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Accept blocks must be signed.
Definition: block_regex.h:56
struct GNUNET_CRYPTO_EddsaSignature signature
The signature.
Definition: block_regex.h:76
struct GNUNET_PeerIdentity peer
Public key of the peer signing.
Definition: block_regex.h:71
Block to announce a regex state.
uint16_t num_edges
Number of edges parting from this state.
Struct to keep state of running searches that have consumed a part of the initial string.
struct GNUNET_HashCode hash
Destination hash of the longest match.
unsigned int longest_match
We just want to look for one edge, the longer the better.
size_t position
Part of the description already consumed by this particular search branch.
struct REGEX_INTERNAL_Search * info
Information about the search.
Type of values in dht_get_results.
const void * data
The raw result data.
size_t size
Number of bytes in data.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model