GNUnet  0.10.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 int 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.

Referenced by block_plugin_regex_create_group().

◆ 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.

Referenced by block_plugin_regex_create_group().

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.

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

Referenced by libgnunet_plugin_block_regex_init().

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 int),
75  else if (0 == strcmp (guard,
76  "filter-size"))
77  bf_size = va_arg (va, unsigned int);
78  else
79  {
80  GNUNET_break (0);
81  bf_size = REGEX_BF_SIZE;
82  }
83  GNUNET_break (NULL == va_arg (va, const char *));
84  return GNUNET_BLOCK_GROUP_bf_create (cls,
85  bf_size,
87  type,
88  nonce,
89  raw_data,
90  raw_data_size);
91 }
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:175
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? Sized so that do not have to re-size the filter too often (to keep it cheap).
Definition: bg_bf.c:250
#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.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
#define REGEX_BF_SIZE
How big is the BF we use for REGEX blocks?
Here is the call graph for this function:
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 114 of file plugin_block_regex.c.

References GNUNET_BLOCK_EVALUATION_OK_DUPLICATE, GNUNET_BLOCK_EVALUATION_OK_MORE, GNUNET_BLOCK_EVALUATION_REQUEST_INVALID, GNUNET_BLOCK_EVALUATION_REQUEST_VALID, GNUNET_BLOCK_EVALUATION_RESULT_INVALID, GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT, GNUNET_BLOCK_GROUP_bf_test_and_set(), GNUNET_break_op, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, and REGEX_BLOCK_check().

Referenced by block_plugin_regex_evaluate().

123 {
124  struct GNUNET_HashCode chash;
125 
126  if (NULL == reply_block)
127  {
128  if (0 != xquery_size)
129  {
130  const char *s;
131 
132  s = (const char *) xquery;
133  if ('\0' != s[xquery_size - 1]) /* must be valid 0-terminated string */
134  {
135  GNUNET_break_op (0);
137  }
138  }
140  }
141  if (0 != xquery_size)
142  {
143  const char *s;
144 
145  s = (const char *) xquery;
146  if ('\0' != s[xquery_size - 1]) /* must be valid 0-terminated string */
147  {
148  GNUNET_break_op (0);
150  }
151  }
152  else if (NULL != query)
153  {
154  /* xquery is required for regex GETs, at least an empty string */
155  GNUNET_break_op (0);
156  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "type %d, query %p, xquery %p\n",
157  type, query, xquery);
159  }
160  switch (REGEX_BLOCK_check (reply_block,
161  reply_block_size,
162  query,
163  xquery))
164  {
165  case GNUNET_SYSERR:
166  GNUNET_break_op(0);
168  case GNUNET_NO:
169  /* xquery missmatch, can happen */
171  default:
172  break;
173  }
174  GNUNET_CRYPTO_hash (reply_block,
175  reply_block_size,
176  &chash);
177  if (GNUNET_YES ==
179  &chash))
182 }
Block does not match query (invalid result)
Block does not match xquery (valid result, not relevant for the request)
#define GNUNET_NO
Definition: gnunet_common.h:81
Valid result, but suppressed because it is a duplicate.
#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:44
A 512-bit hashcode.
Valid result, and there may be more.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
Query format does not match block type (invalid query).
#define GNUNET_log(kind,...)
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
#define GNUNET_YES
Definition: gnunet_common.h:80
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.
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
Query is valid, no reply given.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ 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 205 of file plugin_block_regex.c.

References RegexAcceptBlock::expiration_time, GNUNET_BLOCK_EVALUATION_OK_DUPLICATE, GNUNET_BLOCK_EVALUATION_OK_MORE, GNUNET_BLOCK_EVALUATION_REQUEST_INVALID, GNUNET_BLOCK_EVALUATION_REQUEST_VALID, GNUNET_BLOCK_EVALUATION_RESULT_INVALID, GNUNET_BLOCK_GROUP_bf_test_and_set(), GNUNET_break_op, GNUNET_CRYPTO_eddsa_verify(), GNUNET_CRYPTO_hash(), GNUNET_OK, GNUNET_SIGNATURE_PURPOSE_REGEX_ACCEPT, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_ntoh(), GNUNET_YES, RegexAcceptBlock::peer, GNUNET_PeerIdentity::public_key, RegexAcceptBlock::purpose, GNUNET_TIME_Relative::rel_value_us, RegexAcceptBlock::signature, and GNUNET_CRYPTO_EccSignaturePurpose::size.

Referenced by block_plugin_regex_evaluate().

213 {
214  const struct RegexAcceptBlock *rba;
215  struct GNUNET_HashCode chash;
216 
217  if (0 != xquery_size)
218  {
219  GNUNET_break_op (0);
221  }
222  if (NULL == reply_block)
224  if (sizeof (struct RegexAcceptBlock) != reply_block_size)
225  {
226  GNUNET_break_op(0);
228  }
229  rba = reply_block;
230  if (ntohl (rba->purpose.size) !=
231  sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
232  sizeof (struct GNUNET_TIME_AbsoluteNBO) +
233  sizeof (struct GNUNET_HashCode))
234  {
235  GNUNET_break_op(0);
237  }
239  {
240  /* technically invalid, but can happen without an error, so
241  we're nice by reporting it as a 'duplicate' */
243  }
244  if (GNUNET_OK !=
246  &rba->purpose,
247  &rba->signature,
248  &rba->peer.public_key))
249  {
250  GNUNET_break_op(0);
252  }
253  GNUNET_CRYPTO_hash (reply_block,
254  reply_block_size,
255  &chash);
256  if (GNUNET_YES ==
258  &chash))
261 }
Block does not match query (invalid result)
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:670
uint64_t rel_value_us
The actual value.
struct GNUNET_CRYPTO_EddsaSignature signature
The signature.
Definition: block_regex.h:76
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
Block to announce a peer accepting a state.
Definition: block_regex.h:49
Time for absolute time used by GNUnet, in microseconds and in network byte order. ...
struct GNUNET_PeerIdentity peer
Public key of the peer signing.
Definition: block_regex.h:71
header of what an ECC signature signs this must be followed by "size - 8" bytes of the actual signed ...
int 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:1116
Valid result, but suppressed because it is a duplicate.
#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:44
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:56
A 512-bit hashcode.
Valid result, and there may be more.
#define GNUNET_SIGNATURE_PURPOSE_REGEX_ACCEPT
Accept state in regex DFA.
Query format does not match block type (invalid query).
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:331
#define GNUNET_YES
Definition: gnunet_common.h:80
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
Query is valid, no reply given.
struct GNUNET_CRYPTO_EddsaPublicKey public_key
struct GNUNET_TIME_AbsoluteNBO expiration_time
When does the signature expire?
Definition: block_regex.h:61
Here is the call graph for this function:
Here is the caller graph for this function:

◆ 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 284 of file plugin_block_regex.c.

References evaluate_block_regex(), evaluate_block_regex_accept(), GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED, GNUNET_BLOCK_TYPE_REGEX, GNUNET_BLOCK_TYPE_REGEX_ACCEPT, and result.

Referenced by libgnunet_plugin_block_regex_init().

294 {
296 
297  switch (type)
298  {
300  result = evaluate_block_regex (cls,
301  type,
302  bg,
303  eo,
304  query,
305  xquery, xquery_size,
306  reply_block, reply_block_size);
307  break;
309  result = evaluate_block_regex_accept (cls,
310  type,
311  bg,
312  eo,
313  query,
314  xquery, xquery_size,
315  reply_block, reply_block_size);
316  break;
317 
318  default:
320  }
321  return result;
322 }
Block to store a cadet regex accepting 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 int result
Global testing status.
GNUNET_BLOCK_EvaluationResult
Possible ways for how a block may relate to a query.
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. ...
Specified block type not supported by this plugin.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
Block to store a cadet regex state.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ block_plugin_regex_get_key()

static int 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 337 of file plugin_block_regex.c.

References GNUNET_BLOCK_TYPE_REGEX, GNUNET_BLOCK_TYPE_REGEX_ACCEPT, GNUNET_break, GNUNET_break_op, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, and REGEX_BLOCK_get_key().

Referenced by libgnunet_plugin_block_regex_init().

342 {
343  switch (type)
344  {
346  if (GNUNET_OK !=
347  REGEX_BLOCK_get_key (block, block_size,
348  key))
349  {
350  GNUNET_break_op (0);
351  return GNUNET_NO;
352  }
353  return GNUNET_OK;
355  if (sizeof (struct RegexAcceptBlock) != block_size)
356  {
357  GNUNET_break_op (0);
358  return GNUNET_NO;
359  }
360  *key = ((struct RegexAcceptBlock *) block)->key;
361  return GNUNET_OK;
362  default:
363  GNUNET_break (0);
364  return GNUNET_SYSERR;
365  }
366 }
Block to store a cadet regex accepting state.
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.
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
Block to announce a peer accepting a state.
Definition: block_regex.h:49
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
Block to store a cadet regex state.
Here is the call graph for this function:
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 373 of file plugin_block_regex.c.

References block_plugin_regex_create_group(), block_plugin_regex_evaluate(), block_plugin_regex_get_key(), 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.

374 {
375  static enum GNUNET_BLOCK_Type types[] =
376  {
379  GNUNET_BLOCK_TYPE_ANY /* end of list */
380  };
381  struct GNUNET_BLOCK_PluginFunctions *api;
382 
387  api->types = types;
388  return api;
389 }
Block to store a cadet regex accepting state.
enum GNUNET_BLOCK_Type * types
0-terminated array of block types supported by this plugin.
static int 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.
Any type of block, used as a wildcard when searching.
GNUNET_BLOCK_EvaluationFunction evaluate
Main function of a block plugin.
GNUNET_BLOCK_Type
Blocks in the datastore and the datacache must have a unique 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.
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
#define GNUNET_new(type)
Allocate a struct or union of the given type.
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.
GNUNET_BLOCK_GroupCreateFunction create_group
Create a block group to process a bunch of blocks in a shared context (i.e.
GNUNET_BLOCK_GetKeyFunction get_key
Obtain the key for a given block (if possible).
Block to store a cadet regex state.
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 396 of file plugin_block_regex.c.

References GNUNET_BLOCK_PluginFunctions::cls, and GNUNET_free.

397 {
398  struct GNUNET_BLOCK_PluginFunctions *api = cls;
399 
400  GNUNET_free (api);
401  return NULL;
402 }
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
void * cls
Closure for all of the callbacks.
#define GNUNET_free(ptr)
Wrapper around free.