GNUnet  0.10.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 
61 
65  const char *regex;
66 
71 
76 
81 };
82 
83 
94 static void
95 regex_iterator(void *cls,
96  const struct GNUNET_HashCode *key,
97  const char *proof,
98  int accepting,
99  unsigned int num_edges,
100  const struct REGEX_BLOCK_Edge *edges)
101 {
102  struct REGEX_INTERNAL_Announcement *h = cls;
103  struct RegexBlock *block;
104  size_t size;
105  unsigned int i;
106 
108  "DHT PUT for state %s with proof `%s' and %u edges:\n",
109  GNUNET_h2s(key),
110  proof,
111  num_edges);
112  for (i = 0; i < num_edges; i++)
113  {
115  "Edge %u `%s' towards %s\n",
116  i,
117  edges[i].label,
118  GNUNET_h2s(&edges[i].destination));
119  }
120  if (GNUNET_YES == accepting)
121  {
122  struct RegexAcceptBlock ab;
123 
125  "State %s is accepting, putting own id\n",
126  GNUNET_h2s(key));
127  size = sizeof(struct RegexAcceptBlock);
128  ab.purpose.size = ntohl(sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose) +
129  sizeof(struct GNUNET_TIME_AbsoluteNBO) +
130  sizeof(struct GNUNET_HashCode));
133  ab.key = *key;
135  &ab.peer.public_key);
138  &ab.purpose,
139  &ab.signature));
140 
141  GNUNET_STATISTICS_update(h->stats, "# regex accepting blocks stored",
142  1, GNUNET_NO);
143  GNUNET_STATISTICS_update(h->stats, "# regex accepting block bytes stored",
144  sizeof(struct RegexAcceptBlock), GNUNET_NO);
145  (void)
146  GNUNET_DHT_put(h->dht, key,
150  size,
151  &ab,
153  NULL, NULL);
154  }
155  block = REGEX_BLOCK_create(proof,
156  num_edges,
157  edges,
158  accepting,
159  &size);
160  if (NULL == block)
161  return;
162  (void)GNUNET_DHT_put(h->dht,
163  key,
165  DHT_OPT,
167  size,
168  block,
170  NULL,
171  NULL);
173  "# regex blocks stored",
174  1,
175  GNUNET_NO);
177  "# regex block bytes stored",
178  size,
179  GNUNET_NO);
180  GNUNET_free(block);
181 }
182 
183 
198  const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
199  const char *regex,
200  uint16_t compression,
202 {
204 
205  GNUNET_assert(NULL != dht);
207  h->regex = regex;
208  h->dht = dht;
209  h->stats = stats;
210  h->priv = priv;
211  h->dfa = REGEX_INTERNAL_construct_dfa(regex, strlen(regex), compression);
213  return h;
214 }
215 
216 
223 void
225 {
226  GNUNET_assert(NULL != h->dfa); /* make sure to call announce first */
228  "REGEX_INTERNAL_reannounce: %s\n",
229  h->regex);
232  h);
233 }
234 
235 
242 void
244 {
246  GNUNET_free(h);
247 }
248 
249 
250 /******************************************************************************/
251 
252 
262  size_t position;
263 
268 
273  unsigned int longest_match;
274 
278  struct GNUNET_HashCode hash;
279 };
280 
281 
285 struct Result {
289  size_t size;
290 
294  const void *data;
295 };
296 
297 
307 
312 
316  char *description;
317 
322 
328 
333 
337  unsigned int n_contexts;
338 
343 
348 };
349 
350 
358 static void
359 regex_next_edge(const struct RegexBlock *block,
360  size_t size,
361  struct RegexSearchContext *ctx);
362 
363 
379 static void
381  const struct GNUNET_HashCode *key,
382  const struct GNUNET_PeerIdentity *get_path,
383  unsigned int get_path_length,
384  const struct GNUNET_PeerIdentity *put_path,
385  unsigned int put_path_length,
386  enum GNUNET_BLOCK_Type type,
387  size_t size, const void *data)
388 {
389  const struct RegexAcceptBlock *block = data;
390  struct RegexSearchContext *ctx = cls;
391  struct REGEX_INTERNAL_Search *info = ctx->info;
392 
394  "Regex result accept for %s (key %s)\n",
395  info->description, GNUNET_h2s(key));
396 
398  "# regex accepting blocks found",
399  1, GNUNET_NO);
401  "# regex accepting block bytes found",
402  size, GNUNET_NO);
403  info->callback(info->callback_cls,
404  &block->peer,
405  get_path, get_path_length,
406  put_path, put_path_length);
407 }
408 
409 
417 static void
419  struct RegexSearchContext *ctx)
420 {
421  struct GNUNET_DHT_GetHandle *get_h;
422 
424  "Accept state found, now searching for paths to %s\n",
425  GNUNET_h2s(key),
426  (unsigned int)ctx->position);
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
437  key,
438  get_h,
440 }
441 
442 
460 static void
462  const struct GNUNET_HashCode *key,
463  const struct GNUNET_PeerIdentity *get_path,
464  unsigned int get_path_length,
465  const struct GNUNET_PeerIdentity *put_path,
466  unsigned int put_path_length,
467  enum GNUNET_BLOCK_Type type,
468  size_t size, const void *data)
469 {
470  const struct RegexBlock *block = data;
471  struct RegexSearchContext *ctx = cls;
472  struct REGEX_INTERNAL_Search *info = ctx->info;
473  size_t len;
474  struct Result *copy;
475 
477  "DHT GET result for %s (%s)\n",
478  GNUNET_h2s(key), ctx->info->description);
479  copy = GNUNET_malloc(sizeof(struct Result) + size);
480  copy->size = size;
481  copy->data = &copy[1];
482  GNUNET_memcpy(&copy[1], block, size);
485  key, copy,
487  len = strlen(info->description);
488  if (len == ctx->position) // String processed
489  {
490  if (GNUNET_YES == GNUNET_BLOCK_is_accepting(block, size))
491  {
492  regex_find_path(key, ctx);
493  }
494  else
495  {
496  LOG(GNUNET_ERROR_TYPE_INFO, "block not accepting!\n");
497  /* FIXME REGEX this block not successful, wait for more? start timeout? */
498  }
499  return;
500  }
501  regex_next_edge(block, size, ctx);
502 }
503 
504 
513 static int
515  const struct GNUNET_HashCode * key,
516  void *value)
517 {
518  struct Result *result = value;
519  const struct RegexBlock *block = result->data;
520  struct RegexSearchContext *ctx = cls;
521 
522  if ((GNUNET_YES ==
523  GNUNET_BLOCK_is_accepting(block, result->size)) &&
524  (ctx->position == strlen(ctx->info->description)))
525  {
527  "Found accepting known block\n");
528  regex_find_path(key, ctx);
529  return GNUNET_YES; // We found an accept state!
530  }
532  "* %u, %u, [%u]\n",
533  ctx->position,
534  strlen(ctx->info->description),
535  GNUNET_BLOCK_is_accepting(block, result->size));
536  regex_next_edge(block, result->size, ctx);
537 
538  GNUNET_STATISTICS_update(ctx->info->stats, "# regex cadet blocks iterated",
539  1, GNUNET_NO);
540 
541  return GNUNET_YES;
542 }
543 
544 
554 static int
556  const char *token,
557  size_t len,
558  const struct GNUNET_HashCode *key)
559 {
560  struct RegexSearchContext *ctx = cls;
561  struct REGEX_INTERNAL_Search *info = ctx->info;
562  const char *current;
563  size_t current_len;
564 
565  GNUNET_STATISTICS_update(info->stats, "# regex edges iterated",
566  1, GNUNET_NO);
567  current = &info->description[ctx->position];
568  current_len = strlen(info->description) - ctx->position;
569  if (len > current_len)
570  {
571  LOG(GNUNET_ERROR_TYPE_DEBUG, "Token too long, END\n");
572  return GNUNET_YES;
573  }
574  if (0 != strncmp(current, token, len))
575  {
576  LOG(GNUNET_ERROR_TYPE_DEBUG, "Token doesn't match, END\n");
577  return GNUNET_YES;
578  }
579 
580  if (len > ctx->longest_match)
581  {
582  LOG(GNUNET_ERROR_TYPE_DEBUG, "Token is longer, KEEP\n");
583  ctx->longest_match = len;
584  ctx->hash = *key;
585  }
586  else
587  {
588  LOG(GNUNET_ERROR_TYPE_DEBUG, "Token is not longer, IGNORE\n");
589  }
590 
591  LOG(GNUNET_ERROR_TYPE_DEBUG, "* End of regex edge iterator\n");
592  return GNUNET_YES;
593 }
594 
595 
603 static void
604 regex_next_edge(const struct RegexBlock *block,
605  size_t size,
606  struct RegexSearchContext *ctx)
607 {
608  struct RegexSearchContext *new_ctx;
609  struct REGEX_INTERNAL_Search *info = ctx->info;
610  struct GNUNET_DHT_GetHandle *get_h;
611  struct GNUNET_HashCode *hash;
612  const char *rest;
613  int result;
614 
615  LOG(GNUNET_ERROR_TYPE_DEBUG, "Next edge\n");
616  /* Find the longest match for the current string position,
617  * among tokens in the given block */
618  ctx->longest_match = 0;
619  result = REGEX_BLOCK_iterate(block, size,
620  &regex_edge_iterator, ctx);
621  GNUNET_break(GNUNET_OK == result);
622 
623  /* Did anything match? */
624  if (0 == ctx->longest_match)
625  {
627  "no match in block\n");
628  return;
629  }
630 
631  hash = &ctx->hash;
632  new_ctx = GNUNET_new(struct RegexSearchContext);
633  new_ctx->info = info;
634  new_ctx->position = ctx->position + ctx->longest_match;
635  GNUNET_array_append(info->contexts, info->n_contexts, new_ctx);
636 
637  /* Check whether we already have a DHT GET running for it */
638  if (GNUNET_YES ==
640  {
642  "GET for %s running, END\n",
643  GNUNET_h2s(hash));
645  hash,
647  new_ctx);
648  return; /* We are already looking for it */
649  }
650 
651  GNUNET_STATISTICS_update(info->stats, "# regex nodes traversed",
652  1, GNUNET_NO);
653 
655  "Following edges at %s for offset %u in `%s'\n",
656  GNUNET_h2s(hash),
657  (unsigned int)ctx->position,
658  info->description);
659  rest = &new_ctx->info->description[new_ctx->position];
660  get_h =
661  GNUNET_DHT_get_start(info->dht, /* handle */
662  GNUNET_BLOCK_TYPE_REGEX, /* type */
663  hash, /* key to search */
664  DHT_REPLICATION, /* replication level */
665  DHT_OPT,
666  rest, /* xquery */
667  strlen(rest) + 1, /* xquery bits */
668  &dht_get_string_handler, new_ctx);
669  if (GNUNET_OK !=
671  hash,
672  get_h,
674  {
675  GNUNET_break(0);
676  return;
677  }
678 }
679 
680 
694 struct REGEX_INTERNAL_Search *
696  const char *string,
698  void *callback_cls,
700 {
701  struct REGEX_INTERNAL_Search *h;
702  struct GNUNET_DHT_GetHandle *get_h;
703  struct RegexSearchContext *ctx;
704  struct GNUNET_HashCode key;
705  size_t size;
706  size_t len;
707 
708  /* Initialize handle */
709  GNUNET_assert(NULL != dht);
710  GNUNET_assert(NULL != callback);
711  h = GNUNET_new(struct REGEX_INTERNAL_Search);
712  h->dht = dht;
713  h->description = GNUNET_strdup(string);
714  h->callback = callback;
715  h->callback_cls = callback_cls;
716  h->stats = stats;
719 
720  /* Initialize context */
721  len = strlen(string);
722  size = REGEX_INTERNAL_get_first_key(string, len, &key);
724  "Initial key for `%s' is %s (based on `%.*s')\n",
725  string,
726  GNUNET_h2s(&key),
727  size,
728  string);
729  ctx = GNUNET_new(struct RegexSearchContext);
730  ctx->position = size;
731  ctx->info = h;
733  h->n_contexts,
734  ctx);
735  /* Start search in DHT */
736  get_h = GNUNET_DHT_get_start(h->dht, /* handle */
737  GNUNET_BLOCK_TYPE_REGEX, /* type */
738  &key, /* key to search */
739  DHT_REPLICATION, /* replication level */
740  DHT_OPT,
741  &h->description[size], /* xquery */
742  // FIXME add BLOOMFILTER to exclude filtered peers
743  len + 1 - size, /* xquery bits */
744  // FIXME add BLOOMFILTER SIZE
745  &dht_get_string_handler, ctx);
746  GNUNET_break(
747  GNUNET_OK ==
749  &key,
750  get_h,
752  );
753 
754  return h;
755 }
756 
757 
768 static int
770  const struct GNUNET_HashCode * key,
771  void *value)
772 {
773  struct GNUNET_DHT_GetHandle *h = value;
774 
776  return GNUNET_YES;
777 }
778 
779 
790 static int
792  const struct GNUNET_HashCode * key,
793  void *value)
794 {
795  GNUNET_free(value);
796  return GNUNET_YES;
797 }
798 
799 
805 void
807 {
808  unsigned int i;
809 
812  &regex_cancel_dht_get, NULL);
814  &regex_free_result, NULL);
817  if (0 < h->n_contexts)
818  {
819  for (i = 0; i < h->n_contexts; i++)
820  GNUNET_free(h->contexts[i]);
821  GNUNET_free(h->contexts);
822  }
823  GNUNET_free(h);
824 }
825 
826 
827 /* 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:64
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:74
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:989
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:94
Connection to the DHT service.
Definition: dht_api.c:198
struct GNUNET_PeerIdentity peer
Public key of the peer signing.
Definition: block_regex.h:69
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:54
A 512-bit hashcode.
void GNUNET_DHT_get_stop(struct GNUNET_DHT_GetHandle *get_handle)
Stop async DHT-get.
Definition: dht_api.c:1150
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:961
static unsigned int size
Size of the "table".
Definition: peer.c:66
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:78
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:272
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:1062
#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:655
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:59
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. ...