GNUnet  0.11.x
Macros | Functions
plugin_block_regex.c File Reference

blocks used for regex storage and search More...

#include "platform.h"
#include "gnunet_block_plugin.h"
#include "gnunet_block_group_lib.h"
#include "block_regex.h"
#include "regex_block_lib.h"
#include "gnunet_signatures.h"
Include dependency graph for plugin_block_regex.c:

Go to the source code of this file.

Macros

#define BLOOMFILTER_K   16
 Number of bits we set per entry in the bloomfilter. More...
 
#define REGEX_BF_SIZE   8
 How big is the BF we use for REGEX blocks? More...
 

Functions

static struct GNUNET_BLOCK_Groupblock_plugin_regex_create_group (void *cls, enum GNUNET_BLOCK_Type type, uint32_t nonce, const void *raw_data, size_t raw_data_size, va_list va)
 Create a new block group. More...
 
static enum GNUNET_BLOCK_EvaluationResult evaluate_block_regex (void *cls, enum GNUNET_BLOCK_Type type, struct GNUNET_BLOCK_Group *bg, enum GNUNET_BLOCK_EvaluationOptions eo, const struct GNUNET_HashCode *query, const void *xquery, size_t xquery_size, const void *reply_block, size_t reply_block_size)
 Function called to validate a reply or a request of type GNUNET_BLOCK_TYPE_REGEX. More...
 
static enum GNUNET_BLOCK_EvaluationResult evaluate_block_regex_accept (void *cls, enum GNUNET_BLOCK_Type type, struct GNUNET_BLOCK_Group *bg, enum GNUNET_BLOCK_EvaluationOptions eo, const struct GNUNET_HashCode *query, const void *xquery, size_t xquery_size, const void *reply_block, size_t reply_block_size)
 Function called to validate a reply or a request of type GNUNET_BLOCK_TYPE_REGEX_ACCEPT. More...
 
static enum GNUNET_BLOCK_EvaluationResult block_plugin_regex_evaluate (void *cls, struct GNUNET_BLOCK_Context *ctx, enum GNUNET_BLOCK_Type type, struct GNUNET_BLOCK_Group *bg, enum GNUNET_BLOCK_EvaluationOptions eo, const struct GNUNET_HashCode *query, const void *xquery, size_t xquery_size, const void *reply_block, size_t reply_block_size)
 Function called to validate a reply or a request. More...
 
static enum GNUNET_GenericReturnValue block_plugin_regex_check_query (void *cls, enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode *query, const void *xquery, size_t xquery_size)
 Function called to validate a query. More...
 
static enum GNUNET_GenericReturnValue block_plugin_regex_check_block (void *cls, enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode *query, const void *block, size_t block_size)
 Function called to validate a block for storage. More...
 
static enum GNUNET_BLOCK_ReplyEvaluationResult block_plugin_regex_check_reply (void *cls, enum GNUNET_BLOCK_Type type, struct GNUNET_BLOCK_Group *group, const struct GNUNET_HashCode *query, const void *xquery, size_t xquery_size, const void *reply_block, size_t reply_block_size)
 Function called to validate a reply to a request. More...
 
static enum GNUNET_GenericReturnValue block_plugin_regex_get_key (void *cls, enum GNUNET_BLOCK_Type type, const void *block, size_t block_size, struct GNUNET_HashCode *key)
 Function called to obtain the key for a block. More...
 
void * libgnunet_plugin_block_regex_init (void *cls)
 Entry point for the plugin. More...
 
void * libgnunet_plugin_block_regex_done (void *cls)
 Exit point from the plugin. More...
 

Detailed Description

blocks used for regex storage and search

Author
Bartlomiej Polot

Definition in file plugin_block_regex.c.

Macro Definition Documentation

◆ BLOOMFILTER_K

#define BLOOMFILTER_K   16

Number of bits we set per entry in the bloomfilter.

Do not change!

Definition at line 38 of file plugin_block_regex.c.

◆ REGEX_BF_SIZE

#define REGEX_BF_SIZE   8

How big is the BF we use for REGEX blocks?

Definition at line 44 of file plugin_block_regex.c.

Function Documentation

◆ block_plugin_regex_create_group()

static struct GNUNET_BLOCK_Group* block_plugin_regex_create_group ( void *  cls,
enum GNUNET_BLOCK_Type  type,
uint32_t  nonce,
const void *  raw_data,
size_t  raw_data_size,
va_list  va 
)
static

Create a new block group.

Parameters
ctxblock context in which the block group is created
typetype of the block for which we are creating the group
noncerandom value used to seed the group creation
raw_dataoptional serialized prior state of the group, NULL if unavailable/fresh
raw_data_sizenumber of bytes in raw_data, 0 if unavailable/fresh
vavariable arguments specific to type
Returns
block group handle, NULL if block groups are not supported by this type of block (this is not an error)

Definition at line 60 of file plugin_block_regex.c.

66 {
67  unsigned int bf_size;
68  const char *guard;
69 
70  guard = va_arg (va, const char *);
71  if (0 == strcmp (guard,
72  "seen-set-size"))
73  bf_size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size (va_arg (va, unsigned
74  int),
76  else if (0 == strcmp (guard,
77  "filter-size"))
78  bf_size = va_arg (va, unsigned int);
79  else
80  {
81  GNUNET_break (0);
82  bf_size = REGEX_BF_SIZE;
83  }
84  GNUNET_break (NULL == va_arg (va, const char *));
85  return GNUNET_BLOCK_GROUP_bf_create (cls,
86  bf_size,
88  type,
89  nonce,
90  raw_data,
91  raw_data_size);
92 }
size_t GNUNET_BLOCK_GROUP_compute_bloomfilter_size(unsigned int entry_count, unsigned int k)
How many bytes should a bloomfilter be if we have already seen entry_count responses?...
Definition: bg_bf.c:250
struct GNUNET_BLOCK_Group * GNUNET_BLOCK_GROUP_bf_create(void *cls, size_t bf_size, unsigned int bf_k, enum GNUNET_BLOCK_Type type, uint32_t nonce, const void *raw_data, size_t raw_data_size)
Create a new block group that filters duplicates using a Bloom filter.
Definition: bg_bf.c:174
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define BLOOMFILTER_K
Number of bits we set per entry in the bloomfilter.
#define REGEX_BF_SIZE
How big is the BF we use for REGEX blocks?
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model

Referenced by libgnunet_plugin_block_regex_init().

Here is the caller graph for this function:

◆ evaluate_block_regex()

static enum GNUNET_BLOCK_EvaluationResult evaluate_block_regex ( void *  cls,
enum GNUNET_BLOCK_Type  type,
struct GNUNET_BLOCK_Group bg,
enum GNUNET_BLOCK_EvaluationOptions  eo,
const struct GNUNET_HashCode query,
const void *  xquery,
size_t  xquery_size,
const void *  reply_block,
size_t  reply_block_size 
)
static

Function called to validate a reply or a request of type GNUNET_BLOCK_TYPE_REGEX.

For request evaluation, pass "NULL" for the reply_block. Note that it is assumed that the reply has already been matched to the key (and signatures checked) as it would be done with the GNUNET_BLOCK_get_key() function.

Parameters
clsclosure
typeblock type
bgblock group to evaluate against
eocontrol flags
queryoriginal query (hash)
xqueryextrended query data (can be NULL, depending on type)
xquery_sizenumber of bytes in xquery
reply_blockresponse to validate
reply_block_sizenumber of bytes in reply_block
Returns
characterization of result

Definition at line 60 of file plugin_block_regex.c.

124 {
125  struct GNUNET_HashCode chash;
126 
127  if (NULL == reply_block)
128  {
129  if (0 != xquery_size)
130  {
131  const char *s;
132 
133  s = (const char *) xquery;
134  if ('\0' != s[xquery_size - 1]) /* must be valid 0-terminated string */
135  {
136  GNUNET_break_op (0);
138  }
139  }
141  }
142  if (0 != xquery_size)
143  {
144  const char *s;
145 
146  s = (const char *) xquery;
147  if ('\0' != s[xquery_size - 1]) /* must be valid 0-terminated string */
148  {
149  GNUNET_break_op (0);
151  }
152  }
153  else if (NULL != query)
154  {
155  /* xquery is required for regex GETs, at least an empty string */
156  GNUNET_break_op (0);
157  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "type %d, query %p, xquery %p\n",
158  type, query, xquery);
160  }
161  switch (REGEX_BLOCK_check (reply_block,
162  reply_block_size,
163  query,
164  xquery))
165  {
166  case GNUNET_SYSERR:
167  GNUNET_break_op (0);
169 
170  case GNUNET_NO:
171  /* xquery mismatch, can happen */
173 
174  default:
175  break;
176  }
177  GNUNET_CRYPTO_hash (reply_block,
178  reply_block_size,
179  &chash);
180  if (GNUNET_YES ==
182  &chash))
185 }
#define GNUNET_log(kind,...)
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_NO
Definition: gnunet_common.h:94
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
int GNUNET_BLOCK_GROUP_bf_test_and_set(struct GNUNET_BLOCK_Group *bg, const struct GNUNET_HashCode *hc)
Test if hc is contained in the Bloom filter of bg.
Definition: bg_bf.c:214
@ GNUNET_BLOCK_EVALUATION_RESULT_INVALID
Block does not match query (invalid result)
@ GNUNET_BLOCK_EVALUATION_REQUEST_INVALID
Query format does not match block type (invalid query).
@ GNUNET_BLOCK_EVALUATION_OK_MORE
Valid result, and there may be more.
@ GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT
Block does not match xquery (valid result, not relevant for the request)
@ GNUNET_BLOCK_EVALUATION_OK_DUPLICATE
Valid result, but suppressed because it is a duplicate.
@ GNUNET_BLOCK_EVALUATION_REQUEST_VALID
Query is valid, no reply given.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
@ GNUNET_ERROR_TYPE_ERROR
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.
A 512-bit hashcode.

◆ evaluate_block_regex_accept()

static enum GNUNET_BLOCK_EvaluationResult evaluate_block_regex_accept ( void *  cls,
enum GNUNET_BLOCK_Type  type,
struct GNUNET_BLOCK_Group bg,
enum GNUNET_BLOCK_EvaluationOptions  eo,
const struct GNUNET_HashCode query,
const void *  xquery,
size_t  xquery_size,
const void *  reply_block,
size_t  reply_block_size 
)
static

Function called to validate a reply or a request of type GNUNET_BLOCK_TYPE_REGEX_ACCEPT.

For request evaluation, pass "NULL" for the reply_block. Note that it is assumed that the reply has already been matched to the key (and signatures checked) as it would be done with the GNUNET_BLOCK_get_key() function.

Parameters
clsclosure
typeblock type
bgblock group to evaluate against
eocontrol flags
queryoriginal query (hash)
xqueryextrended query data (can be NULL, depending on type)
xquery_sizenumber of bytes in xquery
reply_blockresponse to validate
reply_block_sizenumber of bytes in reply_block
Returns
characterization of result

Definition at line 60 of file plugin_block_regex.c.

216 {
217  const struct RegexAcceptBlock *rba;
218  struct GNUNET_HashCode chash;
219 
220  if (0 != xquery_size)
221  {
222  GNUNET_break_op (0);
224  }
225  if (NULL == reply_block)
227  if (sizeof(struct RegexAcceptBlock) != reply_block_size)
228  {
229  GNUNET_break_op (0);
231  }
232  rba = reply_block;
233  if (ntohl (rba->purpose.size) !=
234  sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
235  + sizeof(struct GNUNET_TIME_AbsoluteNBO)
236  + sizeof(struct GNUNET_HashCode))
237  {
238  GNUNET_break_op (0);
240  }
242  rba->expiration_time)).
243  rel_value_us)
244  {
245  /* technically invalid, but can happen without an error, so
246  we're nice by reporting it as a 'duplicate' */
248  }
249  if (GNUNET_OK !=
251  &rba->purpose,
252  &rba->signature,
253  &rba->peer.public_key))
254  {
255  GNUNET_break_op (0);
257  }
258  GNUNET_CRYPTO_hash (reply_block,
259  reply_block_size,
260  &chash);
261  if (GNUNET_YES ==
263  &chash))
266 }
@ GNUNET_OK
Definition: gnunet_common.h:95
#define GNUNET_SIGNATURE_PURPOSE_REGEX_ACCEPT
Accept state in regex DFA.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_verify_(uint32_t purpose, const struct GNUNET_CRYPTO_EccSignaturePurpose *validate, const struct GNUNET_CRYPTO_EddsaSignature *sig, const struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Verify EdDSA signature.
Definition: crypto_ecc.c:682
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition: time.c:374
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:699
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 (!...
struct GNUNET_CRYPTO_EddsaPublicKey public_key
Time for absolute time used by GNUnet, in microseconds and in network byte order.
Block to announce a peer accepting a state.
Definition: block_regex.h:50
struct GNUNET_TIME_AbsoluteNBO expiration_time
When does the signature expire?
Definition: block_regex.h:60
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Accept blocks must be signed.
Definition: block_regex.h:55
struct GNUNET_CRYPTO_EddsaSignature signature
The signature.
Definition: block_regex.h:75
struct GNUNET_PeerIdentity peer
Public key of the peer signing.
Definition: block_regex.h:70

◆ block_plugin_regex_evaluate()

static enum GNUNET_BLOCK_EvaluationResult block_plugin_regex_evaluate ( void *  cls,
struct GNUNET_BLOCK_Context ctx,
enum GNUNET_BLOCK_Type  type,
struct GNUNET_BLOCK_Group bg,
enum GNUNET_BLOCK_EvaluationOptions  eo,
const struct GNUNET_HashCode query,
const void *  xquery,
size_t  xquery_size,
const void *  reply_block,
size_t  reply_block_size 
)
static

Function called to validate a reply or a request.

For request evaluation, simply pass "NULL" for the reply_block. Note that it is assumed that the reply has already been matched to the key (and signatures checked) as it would be done with the GNUNET_BLOCK_get_key() function.

Parameters
clsclosure
ctxblock context
typeblock type
bggroup to evaluate against
eocontrol flags
queryoriginal query (hash)
xqueryextrended query data (can be NULL, depending on type)
xquery_sizenumber of bytes in xquery
reply_blockresponse to validate
reply_block_sizenumber of bytes in reply block
Returns
characterization of result

Definition at line 60 of file plugin_block_regex.c.

299 {
301 
302  switch (type)
303  {
306  type,
307  bg,
308  eo,
309  query,
310  xquery, xquery_size,
311  reply_block, reply_block_size);
312  break;
313 
316  type,
317  bg,
318  eo,
319  query,
320  xquery, xquery_size,
321  reply_block, reply_block_size);
322  break;
323 
324  default:
326  }
327  return result;
328 }
static int result
Global testing status.
GNUNET_BLOCK_EvaluationResult
Possible ways for how a block may relate to a query.
@ GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED
Specified block type not supported by this plugin.
@ GNUNET_BLOCK_TYPE_REGEX_ACCEPT
Block to store a cadet regex accepting state.
@ GNUNET_BLOCK_TYPE_REGEX
Block to store a cadet regex state.
static enum GNUNET_BLOCK_EvaluationResult evaluate_block_regex_accept(void *cls, enum GNUNET_BLOCK_Type type, struct GNUNET_BLOCK_Group *bg, enum GNUNET_BLOCK_EvaluationOptions eo, const struct GNUNET_HashCode *query, const void *xquery, size_t xquery_size, const void *reply_block, size_t reply_block_size)
Function called to validate a reply or a request of type GNUNET_BLOCK_TYPE_REGEX_ACCEPT.
static enum GNUNET_BLOCK_EvaluationResult evaluate_block_regex(void *cls, enum GNUNET_BLOCK_Type type, struct GNUNET_BLOCK_Group *bg, enum GNUNET_BLOCK_EvaluationOptions eo, const struct GNUNET_HashCode *query, const void *xquery, size_t xquery_size, const void *reply_block, size_t reply_block_size)
Function called to validate a reply or a request of type GNUNET_BLOCK_TYPE_REGEX.

Referenced by libgnunet_plugin_block_regex_init().

Here is the caller graph for this function:

◆ block_plugin_regex_check_query()

static enum GNUNET_GenericReturnValue block_plugin_regex_check_query ( void *  cls,
enum GNUNET_BLOCK_Type  type,
const struct GNUNET_HashCode query,
const void *  xquery,
size_t  xquery_size 
)
static

Function called to validate a query.

Parameters
clsclosure
ctxblock context
typeblock type
queryoriginal query (hash)
xqueryextrended query data (can be NULL, depending on type)
xquery_sizenumber of bytes in xquery
Returns
GNUNET_OK if the query is fine, GNUNET_NO if not

Definition at line 60 of file plugin_block_regex.c.

348 {
349  switch (type)
350  {
352  if (0 != xquery_size)
353  {
354  const char *s;
355 
356  s = (const char *) xquery;
357  if ('\0' != s[xquery_size - 1]) /* must be valid 0-terminated string */
358  {
359  GNUNET_break_op (0);
360  return GNUNET_NO;
361  }
362  }
363  return GNUNET_OK;
365  if (0 != xquery_size)
366  {
367  GNUNET_break_op (0);
368  return GNUNET_NO;
369  }
370  return GNUNET_OK;
371  default:
372  GNUNET_break (0);
373  return GNUNET_SYSERR;
374  }
375 }

Referenced by libgnunet_plugin_block_regex_init().

Here is the caller graph for this function:

◆ block_plugin_regex_check_block()

static enum GNUNET_GenericReturnValue block_plugin_regex_check_block ( void *  cls,
enum GNUNET_BLOCK_Type  type,
const struct GNUNET_HashCode query,
const void *  block,
size_t  block_size 
)
static

Function called to validate a block for storage.

Parameters
clsclosure
typeblock type
querykey for the block (hash), must match exactly
blockblock data to validate
block_sizenumber of bytes in block
Returns
GNUNET_OK if the block is fine, GNUNET_NO if not

Definition at line 60 of file plugin_block_regex.c.

394 {
395  switch (type)
396  {
398  if (GNUNET_SYSERR ==
399  REGEX_BLOCK_check (block,
400  block_size,
401  query,
402  NULL))
403  return GNUNET_NO;
404  return GNUNET_OK;
406  {
407  const struct RegexAcceptBlock *rba;
408 
409  if (sizeof(struct RegexAcceptBlock) != block_size)
410  {
411  GNUNET_break_op (0);
412  return GNUNET_NO;
413  }
414  rba = block;
415  if (ntohl (rba->purpose.size) !=
416  sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
417  + sizeof(struct GNUNET_TIME_AbsoluteNBO)
418  + sizeof(struct GNUNET_HashCode))
419  {
420  GNUNET_break_op (0);
421  return GNUNET_NO;
422  }
424  rba->expiration_time)))
425  {
426  return GNUNET_NO;
427  }
428  if (GNUNET_OK !=
430  &rba->purpose,
431  &rba->signature,
432  &rba->peer.public_key))
433  {
434  GNUNET_break_op (0);
435  return GNUNET_NO;
436  }
437  return GNUNET_OK;
438  }
439  default:
440  GNUNET_break (0);
441  return GNUNET_SYSERR;
442  }
443 }
bool GNUNET_TIME_absolute_is_past(struct GNUNET_TIME_Absolute abs)
Test if abs is truly in the past (excluding now).
Definition: time.c:638

References BLOOMFILTER_K, GNUNET_BLOCK_GROUP_bf_create(), GNUNET_BLOCK_GROUP_compute_bloomfilter_size(), GNUNET_break, REGEX_BF_SIZE, and type.

Referenced by libgnunet_plugin_block_regex_init().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ block_plugin_regex_check_reply()

static enum GNUNET_BLOCK_ReplyEvaluationResult block_plugin_regex_check_reply ( void *  cls,
enum GNUNET_BLOCK_Type  type,
struct GNUNET_BLOCK_Group group,
const struct GNUNET_HashCode query,
const void *  xquery,
size_t  xquery_size,
const void *  reply_block,
size_t  reply_block_size 
)
static

Function called to validate a reply to a request.

Note that it is assumed that the reply has already been matched to the key (and signatures checked) as it would be done with the GetKeyFunction and the BlockEvaluationFunction.

Parameters
clsclosure
typeblock type
groupwhich block group to use for evaluation
queryoriginal query (hash)
xqueryextrended query data (can be NULL, depending on type)
xquery_sizenumber of bytes in xquery
reply_blockresponse to validate
reply_block_sizenumber of bytes in reply_block
Returns
characterization of result

Definition at line 60 of file plugin_block_regex.c.

472 {
473  struct GNUNET_HashCode chash;
474 
475  switch (type)
476  {
478  if (0 != xquery_size)
479  {
480  const char *s;
481 
482  s = (const char *) xquery;
483  if ('\0' != s[xquery_size - 1]) /* must be valid 0-terminated string */
484  {
485  /* Technically, the query is invalid ... */
486  GNUNET_break (0);
488  }
489  }
490  switch (REGEX_BLOCK_check (reply_block,
491  reply_block_size,
492  query,
493  xquery))
494  {
495  case GNUNET_SYSERR:
496  GNUNET_break_op (0);
498  case GNUNET_NO:
499  /* xquery mismatch, can happen */
501  default:
502  break;
503  }
504  GNUNET_CRYPTO_hash (reply_block,
505  reply_block_size,
506  &chash);
507  if (GNUNET_YES ==
509  &chash))
513  {
514  const struct RegexAcceptBlock *rba;
515 
516  if (sizeof(struct RegexAcceptBlock) != reply_block_size)
517  {
518  GNUNET_break_op (0);
520  }
521  rba = reply_block;
522  if (ntohl (rba->purpose.size) !=
523  sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)
524  + sizeof(struct GNUNET_TIME_AbsoluteNBO)
525  + sizeof(struct GNUNET_HashCode))
526  {
527  GNUNET_break_op (0);
529  }
530  GNUNET_CRYPTO_hash (reply_block,
531  reply_block_size,
532  &chash);
533  if (GNUNET_YES ==
535  &chash))
538  }
539  default:
540  GNUNET_break (0);
542  }
544 }
@ GNUNET_BLOCK_REPLY_OK_MORE
Valid result, and there may be more.
@ GNUNET_BLOCK_REPLY_OK_DUPLICATE
Valid result, but suppressed because it is a duplicate.
@ GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED
Specified block type not supported by any plugin.
@ GNUNET_BLOCK_REPLY_INVALID
Block does not match query (invalid result)
@ GNUNET_BLOCK_REPLY_IRRELEVANT
Block does not match xquery (valid result, not relevant for the request)

Referenced by libgnunet_plugin_block_regex_init().

Here is the caller graph for this function:

◆ block_plugin_regex_get_key()

static enum GNUNET_GenericReturnValue block_plugin_regex_get_key ( void *  cls,
enum GNUNET_BLOCK_Type  type,
const void *  block,
size_t  block_size,
struct GNUNET_HashCode key 
)
static

Function called to obtain the key for a block.

Parameters
clsclosure
typeblock type
blockblock to get the key for
block_sizenumber of bytes in block
keyset to the key (query) for the given block
Returns
GNUNET_OK on success, GNUNET_SYSERR if type not supported (or if extracting a key from a block of this type does not work)

Definition at line 60 of file plugin_block_regex.c.

564 {
565  switch (type)
566  {
568  if (GNUNET_OK !=
569  REGEX_BLOCK_get_key (block,
570  block_size,
571  key))
572  {
573  GNUNET_break_op (0);
574  return GNUNET_NO;
575  }
576  return GNUNET_OK;
578  if (sizeof(struct RegexAcceptBlock) != block_size)
579  {
580  GNUNET_break_op (0);
581  return GNUNET_NO;
582  }
583  *key = ((struct RegexAcceptBlock *) block)->key;
584  return GNUNET_OK;
585  default:
586  GNUNET_break (0);
587  return GNUNET_SYSERR;
588  }
589 }
struct GNUNET_HashCode key
The key used in the DHT.
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.

Referenced by libgnunet_plugin_block_regex_init().

Here is the caller graph for this function:

◆ libgnunet_plugin_block_regex_init()

void* libgnunet_plugin_block_regex_init ( void *  cls)

Entry point for the plugin.

Definition at line 596 of file plugin_block_regex.c.

597 {
598  static const enum GNUNET_BLOCK_Type types[] = {
601  GNUNET_BLOCK_TYPE_ANY /* end of list */
602  };
603  struct GNUNET_BLOCK_PluginFunctions *api;
604 
612  api->types = types;
613  return api;
614 }
GNUNET_BLOCK_Type
Blocks in the datastore and the datacache must have a unique type.
@ GNUNET_BLOCK_TYPE_ANY
Any type of block, used as a wildcard when searching.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static struct GNUNET_BLOCK_Group * block_plugin_regex_create_group(void *cls, enum GNUNET_BLOCK_Type type, uint32_t nonce, const void *raw_data, size_t raw_data_size, va_list va)
Create a new block group.
static enum GNUNET_GenericReturnValue block_plugin_regex_check_block(void *cls, enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode *query, const void *block, size_t block_size)
Function called to validate a block for storage.
static enum GNUNET_BLOCK_ReplyEvaluationResult block_plugin_regex_check_reply(void *cls, enum GNUNET_BLOCK_Type type, struct GNUNET_BLOCK_Group *group, const struct GNUNET_HashCode *query, const void *xquery, size_t xquery_size, const void *reply_block, size_t reply_block_size)
Function called to validate a reply to a request.
static enum GNUNET_GenericReturnValue block_plugin_regex_get_key(void *cls, enum GNUNET_BLOCK_Type type, const void *block, size_t block_size, struct GNUNET_HashCode *key)
Function called to obtain the key for a block.
static enum GNUNET_GenericReturnValue block_plugin_regex_check_query(void *cls, enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode *query, const void *xquery, size_t xquery_size)
Function called to validate a query.
static enum GNUNET_BLOCK_EvaluationResult block_plugin_regex_evaluate(void *cls, struct GNUNET_BLOCK_Context *ctx, enum GNUNET_BLOCK_Type type, struct GNUNET_BLOCK_Group *bg, enum GNUNET_BLOCK_EvaluationOptions eo, const struct GNUNET_HashCode *query, const void *xquery, size_t xquery_size, const void *reply_block, size_t reply_block_size)
Function called to validate a reply or a request.
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
enum GNUNET_BLOCK_Type * types
0-terminated array of block types supported by this plugin.
GNUNET_BLOCK_QueryEvaluationFunction check_query
Check that a query is well-formed.
GNUNET_BLOCK_BlockEvaluationFunction check_block
Check that a block is well-formed.
GNUNET_BLOCK_GetKeyFunction get_key
Obtain the key for a given block (if possible).
GNUNET_BLOCK_ReplyEvaluationFunction check_reply
Check that a reply block matches a query.
GNUNET_BLOCK_GroupCreateFunction create_group
Create a block group to process a bunch of blocks in a shared context (i.e.
GNUNET_BLOCK_EvaluationFunction evaluate
Main function of a block plugin.

References block_plugin_regex_check_block(), block_plugin_regex_check_query(), block_plugin_regex_check_reply(), block_plugin_regex_create_group(), block_plugin_regex_evaluate(), block_plugin_regex_get_key(), GNUNET_BLOCK_PluginFunctions::check_block, GNUNET_BLOCK_PluginFunctions::check_query, GNUNET_BLOCK_PluginFunctions::check_reply, GNUNET_BLOCK_PluginFunctions::create_group, GNUNET_BLOCK_PluginFunctions::evaluate, GNUNET_BLOCK_PluginFunctions::get_key, GNUNET_BLOCK_TYPE_ANY, GNUNET_BLOCK_TYPE_REGEX, GNUNET_BLOCK_TYPE_REGEX_ACCEPT, GNUNET_new, and GNUNET_BLOCK_PluginFunctions::types.

Here is the call graph for this function:

◆ libgnunet_plugin_block_regex_done()

void* libgnunet_plugin_block_regex_done ( void *  cls)

Exit point from the plugin.

Definition at line 621 of file plugin_block_regex.c.

622 {
623  struct GNUNET_BLOCK_PluginFunctions *api = cls;
624 
625  GNUNET_free (api);
626  return NULL;
627 }
#define GNUNET_free(ptr)
Wrapper around free.
void * cls
Closure for all of the callbacks.

References GNUNET_BLOCK_PluginFunctions::cls, and GNUNET_free.