GNUnet  0.11.x
Data Structures | Typedefs | Functions
regex_block_lib.h File Reference

common function to manipulate blocks stored by regex in the DHT More...

#include "platform.h"
#include "block_regex.h"
Include dependency graph for regex_block_lib.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  REGEX_BLOCK_Edge
 Edge representation. More...
 

Typedefs

typedef int(* REGEX_INTERNAL_EgdeIterator) (void *cls, const char *token, size_t len, const struct GNUNET_HashCode *key)
 Iterator over edges in a block. More...
 

Functions

int REGEX_BLOCK_check_proof (const char *proof, size_t proof_len, const struct GNUNET_HashCode *key)
 Check if the given 'proof' matches the given 'key'. More...
 
int REGEX_BLOCK_check (const struct RegexBlock *block, size_t size, const struct GNUNET_HashCode *query, const char *xquery)
 Check if the regex block is well formed, including all edges. More...
 
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. More...
 
int REGEX_BLOCK_get_key (const struct RegexBlock *block, size_t block_len, struct GNUNET_HashCode *key)
 Obtain the key that a particular block is to be stored under. More...
 
int GNUNET_BLOCK_is_accepting (const struct RegexBlock *block, size_t block_len)
 Test if this block is marked as being an accept state. More...
 
struct RegexBlockREGEX_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. More...
 

Detailed Description

common function to manipulate blocks stored by regex in the DHT

Author
Bartlomiej Polot

Definition in file regex_block_lib.h.

Typedef Documentation

◆ REGEX_INTERNAL_EgdeIterator

typedef int(* REGEX_INTERNAL_EgdeIterator) (void *cls, const char *token, size_t len, const struct GNUNET_HashCode *key)

Iterator over edges in a block.

Parameters
clsClosure.
tokenToken that follows to next state.
lenLength of token.
keyHash of next state.
Returns
GNUNET_YES if should keep iterating, GNUNET_NO otherwise.

Definition at line 112 of file regex_block_lib.h.

Function Documentation

◆ REGEX_BLOCK_check_proof()

int REGEX_BLOCK_check_proof ( const char *  proof,
size_t  proof_len,
const struct GNUNET_HashCode key 
)

Check if the given 'proof' matches the given 'key'.

Parameters
proofpartial regex of a state
proof_lennumber of bytes in proof
keyhash of a state.
Returns
GNUNET_OK if the proof is valid for the given key.
Parameters
proofpartial regex of a state
proof_lennumber of bytes in 'proof'
keyhash of a state.
Returns
GNUNET_OK if the proof is valid for the given key.

Definition at line 122 of file regex_block_lib.c.

References GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_hash_cmp(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NO, and GNUNET_OK.

125 {
126  struct GNUNET_HashCode key_check;
127 
128  if ((NULL == proof) || (NULL == key))
129  {
130  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Proof check failed, was NULL.\n");
131  return GNUNET_NO;
132  }
133  GNUNET_CRYPTO_hash (proof, proof_len, &key_check);
134  return (0 ==
135  GNUNET_CRYPTO_hash_cmp (key, &key_check)) ? GNUNET_OK : GNUNET_NO;
136 }
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static uint64_t proof
Definition: gnunet-scrypt.c:41
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:48
A 512-bit hashcode.
int GNUNET_CRYPTO_hash_cmp(const struct GNUNET_HashCode *h1, const struct GNUNET_HashCode *h2)
Compare function for HashCodes, producing a total ordering of all hashcodes.
Definition: crypto_hash.c:294
#define GNUNET_log(kind,...)
Here is the call graph for this function:

◆ REGEX_BLOCK_check()

int REGEX_BLOCK_check ( const struct RegexBlock block,
size_t  size,
const struct GNUNET_HashCode query,
const char *  xquery 
)

Check if the regex block is well formed, including all edges.

Parameters
blockThe start of the block.
sizeThe size of the block.
querythe query for the block
xqueryString describing the edge we are looking for. Can be NULL in case this is a put block.
Returns
GNUNET_OK in case it's fine. GNUNET_NO in case the xquery exists and is not found (IRRELEVANT). GNUNET_SYSERR if the block is invalid.
Parameters
blockThe start of the block.
sizeThe size of the block.
querythe query for the block
xqueryString describing the edge we are looking for. Can be NULL in case this is a put block.
Returns
GNUNET_OK in case it's fine. GNUNET_NO in case the xquery exists and is not found (IRRELEVANT). GNUNET_SYSERR if the block is invalid.

Definition at line 203 of file regex_block_lib.c.

References check_edge(), CheckEdgeContext::found, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_memcmp, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, RegexBlock::is_accepting, LOG, REGEX_BLOCK_get_key(), REGEX_BLOCK_iterate(), res, and CheckEdgeContext::xquery.

Referenced by evaluate_block_regex().

207 {
208  struct GNUNET_HashCode key;
209  struct CheckEdgeContext ctx;
210  int res;
211 
213  "Block check\n");
214  if (GNUNET_OK !=
215  REGEX_BLOCK_get_key (block, size,
216  &key))
217  {
218  GNUNET_break_op (0);
219  return GNUNET_SYSERR;
220  }
221  if ((NULL != query) &&
222  (0 != GNUNET_memcmp (&key,
223  query)) )
224  {
225  GNUNET_break_op (0);
226  return GNUNET_SYSERR;
227  }
228  if ((GNUNET_YES == ntohs (block->is_accepting)) &&
229  ((NULL == xquery) || ('\0' == xquery[0])))
230  {
232  " out! Is accepting: %u, xquery %p\n",
233  ntohs (block->is_accepting),
234  xquery);
235  return GNUNET_OK;
236  }
237  ctx.xquery = xquery;
238  ctx.found = GNUNET_NO;
239  res = REGEX_BLOCK_iterate (block, size, &check_edge, &ctx);
240  if (GNUNET_SYSERR == res)
241  return GNUNET_SYSERR;
242  if (NULL == xquery)
243  return GNUNET_YES;
244  LOG (GNUNET_ERROR_TYPE_DEBUG, "Result %d\n", ctx.found);
245  return ctx.found;
246 }
Struct to keep track of the xquery while iterating all the edges in a block.
int REGEX_BLOCK_get_key(const struct RegexBlock *block, size_t block_len, struct GNUNET_HashCode *key)
Obtain the key that a particular block is to be stored under.
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.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define LOG(kind,...)
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
A 512-bit hashcode.
static int res
struct GNUNET_HashCode key
The key used in the DHT.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:67
const char * xquery
Xquery: string we are looking for.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
static int check_edge(void *cls, const char *token, size_t len, const struct GNUNET_HashCode *key)
Iterator over all edges in a block, checking for a presence of a given query.
#define GNUNET_YES
Definition: gnunet_common.h:77
int16_t is_accepting
Is this state an accepting state?
Here is the call graph for this function:
Here is the caller graph for this function:

◆ REGEX_BLOCK_iterate()

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.

Parameters
blockBlock to iterate over.
sizeSize of block.
iteratorFunction to call on each edge in the block.
iter_clsClosure for the iterator.
Returns
GNUNET_SYSERR if an error has been encountered. GNUNET_OK if no error has been encountered. Note that if the iterator stops the iteration by returning GNUNET_NO, the block will no longer be checked for further errors. The return value will be GNUNET_OK meaning that no errors were found until the edge last notified to the iterator, but there might be errors in further edges.
Parameters
blockBlock to iterate over.
sizeSize of block.
iteratorFunction to call on each edge in the block.
iter_clsClosure for the iterator.
Returns
GNUNET_SYSERR if an error has been encountered. GNUNET_OK if no error has been encountered. Note that if the iterator stops the iteration by returning GNUNET_NO, the block will no longer be checked for further errors. The return value will be GNUNET_OK meaning that no errors were found until the edge last notified to the iterator, but there might be errors in further edges.

Definition at line 308 of file regex_block_lib.c.

References EdgeInfo::destination_index, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, len, LOG, RegexBlock::num_destinations, RegexBlock::num_edges, RegexBlock::proof_len, and EdgeInfo::token_length.

Referenced by REGEX_BLOCK_check(), and regex_next_edge().

312 {
313  uint16_t len;
314  const struct GNUNET_HashCode *destinations;
315  const struct EdgeInfo *edges;
316  const char *aux;
317  uint16_t num_destinations;
318  uint16_t num_edges;
319  size_t total;
320  unsigned int n;
321  size_t off;
322 
323  LOG (GNUNET_ERROR_TYPE_DEBUG, "Block iterate\n");
324  if (size < sizeof(struct RegexBlock))
325  {
326  GNUNET_break_op (0);
327  return GNUNET_SYSERR;
328  }
329  num_destinations = ntohs (block->num_destinations);
330  num_edges = ntohs (block->num_edges);
331  len = ntohs (block->proof_len);
332  destinations = (const struct GNUNET_HashCode *) &block[1];
333  edges = (const struct EdgeInfo *) &destinations[num_destinations];
334  aux = (const char *) &edges[num_edges];
335  total = sizeof(struct RegexBlock) + num_destinations * sizeof(struct
337  + num_edges * sizeof(struct EdgeInfo) + len;
338  if (size < total)
339  {
340  GNUNET_break_op (0);
341  return GNUNET_SYSERR;
342  }
343  for (n = 0; n < num_edges; n++)
344  total += ntohs (edges[n].token_length);
345  if (size != total)
346  {
347  fprintf (stderr, "Expected %u, got %u\n",
348  (unsigned int) size,
349  (unsigned int) total);
350  GNUNET_break_op (0);
351  return GNUNET_SYSERR;
352  }
353  off = len;
355  "Start iterating block of size %u, proof %u, off %u edges %u\n",
356  size, len, off, n);
357  /* &aux[off] always points to our token */
358  for (n = 0; n < num_edges; n++)
359  {
361  "Edge %u/%u, off %u tokenlen %u (%.*s)\n",
362  n + 1, num_edges, off,
363  ntohs (edges[n].token_length), ntohs (edges[n].token_length),
364  &aux[off]);
365  if (NULL != iterator)
366  if (GNUNET_NO == iterator (iter_cls,
367  &aux[off],
368  ntohs (edges[n].token_length),
369  &destinations[ntohs (
370  edges[n].destination_index)]))
371  return GNUNET_OK;
372  off += ntohs (edges[n].token_length);
373  }
374  return GNUNET_OK;
375 }
static int iterator(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Iterator over hash map entries.
uint16_t num_edges
Number of edges parting from this state.
Block to announce a regex state.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define LOG(kind,...)
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
uint16_t num_destinations
Nubmer of unique destinations reachable from this state.
uint16_t proof_len
Length of the proof regex string.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
A 512-bit hashcode.
Information for each edge.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:67
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the caller graph for this function:

◆ REGEX_BLOCK_get_key()

int REGEX_BLOCK_get_key ( const struct RegexBlock block,
size_t  block_len,
struct GNUNET_HashCode key 
)

Obtain the key that a particular block is to be stored under.

Parameters
blockblock to get the key from
block_lennumber of bytes in block
keywhere to store the key
Returns
GNUNET_OK on success, GNUNET_SYSERR if the block is malformed
Parameters
blockblock to get the key from
block_lennumber of bytes in block
keywhere to store the key
Returns
GNUNET_OK on success, GNUNET_SYSERR if the block is malformed

Definition at line 258 of file regex_block_lib.c.

References GNUNET_break_op, GNUNET_CRYPTO_hash(), GNUNET_OK, GNUNET_SYSERR, len, RegexBlock::num_destinations, RegexBlock::num_edges, and RegexBlock::proof_len.

Referenced by block_plugin_regex_get_key(), and REGEX_BLOCK_check().

261 {
262  uint16_t len;
263  const struct GNUNET_HashCode *destinations;
264  const struct EdgeInfo *edges;
265  uint16_t num_destinations;
266  uint16_t num_edges;
267  size_t total;
268 
269  if (block_len < sizeof(struct RegexBlock))
270  {
271  GNUNET_break_op (0);
272  return GNUNET_SYSERR;
273  }
274  num_destinations = ntohs (block->num_destinations);
275  num_edges = ntohs (block->num_edges);
276  len = ntohs (block->proof_len);
277  destinations = (const struct GNUNET_HashCode *) &block[1];
278  edges = (const struct EdgeInfo *) &destinations[num_destinations];
279  total = sizeof(struct RegexBlock) + num_destinations * sizeof(struct
281  + num_edges * sizeof(struct EdgeInfo) + len;
282  if (block_len < total)
283  {
284  GNUNET_break_op (0);
285  return GNUNET_SYSERR;
286  }
287  GNUNET_CRYPTO_hash (&edges[num_edges], len, key);
288  return GNUNET_OK;
289 }
uint16_t num_edges
Number of edges parting from this state.
Block to announce a regex state.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
uint16_t num_destinations
Nubmer of unique destinations reachable from this state.
uint16_t proof_len
Length of the proof regex string.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:48
A 512-bit hashcode.
Information for each edge.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_BLOCK_is_accepting()

int GNUNET_BLOCK_is_accepting ( const struct RegexBlock block,
size_t  size 
)

Test if this block is marked as being an accept state.

Parameters
blockblock to test
sizenumber of bytes in block
Returns
GNUNET_YES if the block is accepting, GNUNET_NO if not

Definition at line 101 of file regex_block_lib.c.

References GNUNET_break_op, GNUNET_SYSERR, and RegexBlock::is_accepting.

Referenced by dht_get_string_handler(), and regex_result_iterator().

103 {
104  if (size < sizeof(struct RegexBlock))
105  {
106  GNUNET_break_op (0);
107  return GNUNET_SYSERR;
108  }
109  return ntohs (block->is_accepting);
110 }
Block to announce a regex state.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:67
int16_t is_accepting
Is this state an accepting state?
Here is the caller graph for this function:

◆ REGEX_BLOCK_create()

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.

Parameters
proofproof string for the block
num_edgesnumber of edges in the block
edgesthe edges of the block
acceptingis this an accepting state
rsizeset to the size of the returned block (OUT-only)
Returns
the regex block, NULL on error

Definition at line 389 of file regex_block_lib.c.

References REGEX_BLOCK_Edge::destination, EdgeInfo::destination_index, GNUNET_break, GNUNET_CONSTANTS_MAX_BLOCK_SIZE, GNUNET_malloc, GNUNET_memcpy, RegexBlock::is_accepting, len, RegexBlock::num_destinations, RegexBlock::num_edges, RegexBlock::proof_len, and EdgeInfo::token_length.

Referenced by regex_iterator().

394 {
395  struct RegexBlock *block;
396  struct GNUNET_HashCode destinations[1024]; /* 1024 = 64k/64 bytes/key == absolute MAX */
397  uint16_t destination_indices[num_edges];
398  struct GNUNET_HashCode *dests;
399  struct EdgeInfo *edgeinfos;
400  size_t off;
401  size_t len;
402  size_t total;
403  size_t slen;
404  unsigned int unique_destinations;
405  unsigned int j;
406  unsigned int i;
407  char *aux;
408 
409  len = strlen (proof);
410  if (len > UINT16_MAX)
411  {
412  GNUNET_break (0);
413  return NULL;
414  }
415  unique_destinations = 0;
416  total = sizeof(struct RegexBlock) + len;
417  for (i = 0; i < num_edges; i++)
418  {
419  slen = strlen (edges[i].label);
420  if (slen > UINT16_MAX)
421  {
422  GNUNET_break (0);
423  return NULL;
424  }
425  total += slen;
426  for (j = 0; j < unique_destinations; j++)
427  if (0 == memcmp (&destinations[j],
428  &edges[i].destination,
429  sizeof(struct GNUNET_HashCode)))
430  break;
431  if (j >= 1024)
432  {
433  GNUNET_break (0);
434  return NULL;
435  }
436  destination_indices[i] = j;
437  if (j == unique_destinations)
438  destinations[unique_destinations++] = edges[i].destination;
439  }
440  total += num_edges * sizeof(struct EdgeInfo) + unique_destinations
441  * sizeof(struct GNUNET_HashCode);
442  if (total >= GNUNET_CONSTANTS_MAX_BLOCK_SIZE)
443  {
444  GNUNET_break (0);
445  return NULL;
446  }
447  block = GNUNET_malloc (total);
448  block->proof_len = htons (len);
449  block->is_accepting = htons (accepting);
450  block->num_edges = htons (num_edges);
451  block->num_destinations = htons (unique_destinations);
452  dests = (struct GNUNET_HashCode *) &block[1];
453  GNUNET_memcpy (dests, destinations, sizeof(struct GNUNET_HashCode)
454  * unique_destinations);
455  edgeinfos = (struct EdgeInfo *) &dests[unique_destinations];
456  aux = (char *) &edgeinfos[num_edges];
457  off = len;
458  GNUNET_memcpy (aux, proof, len);
459  for (i = 0; i < num_edges; i++)
460  {
461  slen = strlen (edges[i].label);
462  edgeinfos[i].token_length = htons ((uint16_t) slen);
463  edgeinfos[i].destination_index = htons (destination_indices[i]);
464  GNUNET_memcpy (&aux[off],
465  edges[i].label,
466  slen);
467  off += slen;
468  }
469  *rsize = total;
470  return block;
471 }
struct GNUNET_HashCode destination
Destionation of the edge.
uint16_t destination_index
Index of the destination of this edge in the unique destinations array.
uint16_t num_edges
Number of edges parting from this state.
Block to announce a regex state.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
uint16_t num_destinations
Nubmer of unique destinations reachable from this state.
uint16_t proof_len
Length of the proof regex string.
static uint64_t proof
Definition: gnunet-scrypt.c:41
A 512-bit hashcode.
uint16_t token_length
Number of bytes the token for this edge takes in the token area.
Information for each edge.
#define GNUNET_CONSTANTS_MAX_BLOCK_SIZE
Largest block that can be stored in the DHT.
int16_t is_accepting
Is this state an accepting state?
#define GNUNET_malloc(size)
Wrapper around malloc.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
Here is the caller graph for this function: