GNUnet  0.20.0
plugin_block_dht.c File Reference

block plugin for DHT internals (right now, find-peer requests only); other plugins should be used to store "useful" data in the DHT (see fs block plugin) More...

Include dependency graph for plugin_block_dht.c:

Go to the source code of this file.

Macros

#define DEBUG_DHT   GNUNET_EXTRA_LOGGING
 
#define BLOOMFILTER_K   16
 Number of bits we set per entry in the bloomfilter. More...
 

Functions

static struct GNUNET_BLOCK_Groupblock_plugin_dht_create_group (void *cls, enum GNUNET_BLOCK_Type type, const void *raw_data, size_t raw_data_size, va_list va)
 Create a new block group. More...
 
static enum GNUNET_GenericReturnValue block_plugin_dht_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_dht_check_block (void *cls, enum GNUNET_BLOCK_Type type, const void *block, size_t block_size)
 Function called to validate a block for storage. More...
 
static enum GNUNET_BLOCK_ReplyEvaluationResult block_plugin_dht_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_dht_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_dht_init (void *cls)
 Entry point for the plugin. More...
 
void * libgnunet_plugin_block_dht_done (void *cls)
 Exit point from the plugin. More...
 

Detailed Description

block plugin for DHT internals (right now, find-peer requests only); other plugins should be used to store "useful" data in the DHT (see fs block plugin)

Author
Christian Grothoff

Definition in file plugin_block_dht.c.

Macro Definition Documentation

◆ DEBUG_DHT

#define DEBUG_DHT   GNUNET_EXTRA_LOGGING

Definition at line 35 of file plugin_block_dht.c.

◆ BLOOMFILTER_K

#define BLOOMFILTER_K   16

Number of bits we set per entry in the bloomfilter.

Do not change!

Definition at line 41 of file plugin_block_dht.c.

Function Documentation

◆ block_plugin_dht_create_group()

static struct GNUNET_BLOCK_Group* block_plugin_dht_create_group ( void *  cls,
enum GNUNET_BLOCK_Type  type,
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
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 56 of file plugin_block_dht.c.

61 {
62  unsigned int bf_size;
63  const char *guard;
64 
65  guard = va_arg (va, const char *);
66  if (0 == strcmp (guard,
67  "seen-set-size"))
68  bf_size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size (va_arg (va,
69  unsigned int),
71  else if (0 == strcmp (guard,
72  "filter-size"))
73  bf_size = va_arg (va, unsigned int);
74  else
75  {
76  GNUNET_break (0);
77  bf_size = 8;
78  }
79  GNUNET_break (NULL == va_arg (va, const char *));
80  return GNUNET_BLOCK_GROUP_bf_create (cls,
81  bf_size,
83  type,
84  raw_data,
85  raw_data_size);
86 }
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:268
struct GNUNET_BLOCK_Group * GNUNET_BLOCK_GROUP_bf_create(void *cls, size_t bf_size, unsigned int bf_k, enum GNUNET_BLOCK_Type type, 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:173
#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

Referenced by libgnunet_plugin_block_dht_init().

Here is the caller graph for this function:

◆ block_plugin_dht_check_query()

static enum GNUNET_GenericReturnValue block_plugin_dht_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
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 56 of file plugin_block_dht.c.

105 {
106  switch (type)
107  {
109  if (0 != xquery_size)
110  {
111  GNUNET_break_op (0);
112  return GNUNET_NO;
113  }
114  return GNUNET_OK;
116  if (0 != xquery_size)
117  {
118  GNUNET_break_op (0);
119  return GNUNET_NO;
120  }
121  return GNUNET_OK;
122  default:
123  GNUNET_break (0);
124  return GNUNET_SYSERR;
125  }
126 }
@ GNUNET_BLOCK_TYPE_LEGACY_HELLO
Legacy type of a block that contains a HELLO for a peer.
@ GNUNET_BLOCK_TYPE_DHT_HELLO
Type of a block that contains a DHT-NG HELLO for a peer.
@ GNUNET_OK
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.

Referenced by libgnunet_plugin_block_dht_init().

Here is the caller graph for this function:

◆ block_plugin_dht_check_block()

static enum GNUNET_GenericReturnValue block_plugin_dht_check_block ( void *  cls,
enum GNUNET_BLOCK_Type  type,
const void *  block,
size_t  block_size 
)
static

Function called to validate a block for storage.

Parameters
clsclosure
typeblock type
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 56 of file plugin_block_dht.c.

143 {
144  switch (type)
145  {
147  {
148  const struct GNUNET_HELLO_Message *hello;
149  struct GNUNET_PeerIdentity pid;
150  const struct GNUNET_MessageHeader *msg;
151 
152  if (block_size < sizeof(struct GNUNET_MessageHeader))
153  {
154  GNUNET_break_op (0);
155  return GNUNET_NO;
156  }
157  msg = block;
158  if (block_size != ntohs (msg->size))
159  {
160  GNUNET_break_op (0);
161  return GNUNET_NO;
162  }
163  hello = block;
164  if (GNUNET_OK !=
165  GNUNET_HELLO_get_id (hello,
166  &pid))
167  {
168  GNUNET_break_op (0);
169  return GNUNET_NO;
170  }
171  return GNUNET_OK;
172  }
174  {
175  struct GNUNET_HELLO_Builder *b;
176  struct GNUNET_PeerIdentity pid;
177  struct GNUNET_HashCode h_pid;
178 
180  block_size);
181  if (NULL == b)
182  {
183  GNUNET_break (0);
184  return GNUNET_NO;
185  }
187  &pid,
188  NULL, NULL);
190  sizeof (pid),
191  &h_pid);
193  return GNUNET_OK;
194  }
195  default:
196  GNUNET_break (0);
197  return GNUNET_SYSERR;
198  }
199 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
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
struct GNUNET_HELLO_Builder * GNUNET_HELLO_builder_from_block(const void *block, size_t block_size)
Parse block into builder.
Definition: hello-uri.c:360
void GNUNET_HELLO_builder_free(struct GNUNET_HELLO_Builder *builder)
Release resources of a builder.
Definition: hello-uri.c:319
void GNUNET_HELLO_builder_iterate(const struct GNUNET_HELLO_Builder *builder, struct GNUNET_PeerIdentity *pid, GNUNET_HELLO_UriCallback uc, void *uc_cls)
Iterate over URIs in a builder.
Definition: hello-uri.c:822
int GNUNET_HELLO_get_id(const struct GNUNET_HELLO_Message *hello, struct GNUNET_PeerIdentity *peer)
Get the peer identity from a HELLO message.
Definition: hello.c:649
Context for building (or parsing) HELLO URIs.
Definition: hello-uri.c:184
A HELLO message is used to exchange information about transports with other peers.
A 512-bit hashcode.
Header for all communications.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
The identity of the host (wraps the signing key of the peer).

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

Referenced by libgnunet_plugin_block_dht_init().

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

◆ block_plugin_dht_check_reply()

static enum GNUNET_BLOCK_ReplyEvaluationResult block_plugin_dht_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 56 of file plugin_block_dht.c.

228 {
229  switch (type)
230  {
232  {
233  /* LEGACY */
234  const struct GNUNET_MessageHeader *msg = reply_block;
235  const struct GNUNET_HELLO_Message *hello = reply_block;
236  struct GNUNET_PeerIdentity pid;
237  struct GNUNET_HashCode phash;
238 
239  GNUNET_assert (reply_block_size >= sizeof(struct GNUNET_MessageHeader));
240  GNUNET_assert (reply_block_size == ntohs (msg->size));
242  GNUNET_HELLO_get_id (hello,
243  &pid));
245  sizeof(pid),
246  &phash);
247  if (GNUNET_YES ==
249  &phash))
252  }
254  {
255  struct GNUNET_HELLO_Builder *b;
256  struct GNUNET_PeerIdentity pid;
257  struct GNUNET_HashCode h_pid;
258 
259  b = GNUNET_HELLO_builder_from_block (reply_block,
260  reply_block_size);
261  GNUNET_assert (NULL != b);
263  &pid,
264  NULL, NULL);
266  sizeof (pid),
267  &h_pid);
269  if (GNUNET_YES ==
271  &h_pid))
274  }
275  default:
277  }
278 }
enum GNUNET_GenericReturnValue 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:232
@ 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_YES
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.

Referenced by libgnunet_plugin_block_dht_init().

Here is the caller graph for this function:

◆ block_plugin_dht_get_key()

static enum GNUNET_GenericReturnValue block_plugin_dht_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 block
[out]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 56 of file plugin_block_dht.c.

298 {
299  switch (type)
300  {
302  {
303  /* LEGACY */
304  const struct GNUNET_MessageHeader *msg;
305  const struct GNUNET_HELLO_Message *hello;
306  struct GNUNET_PeerIdentity *pid;
307 
308  if (block_size < sizeof(struct GNUNET_MessageHeader))
309  {
310  GNUNET_break_op (0);
311  memset (key,
312  0,
313  sizeof (*key));
314  return GNUNET_OK;
315  }
316  msg = block;
317  if (block_size != ntohs (msg->size))
318  {
319  GNUNET_break_op (0);
320  memset (key,
321  0,
322  sizeof (*key));
323  return GNUNET_OK;
324  }
325  hello = block;
326  memset (key,
327  0,
328  sizeof(*key));
329  pid = (struct GNUNET_PeerIdentity *) key;
330  if (GNUNET_OK !=
331  GNUNET_HELLO_get_id (hello,
332  pid))
333  {
334  GNUNET_break_op (0);
335  memset (key,
336  0,
337  sizeof (*key));
338  return GNUNET_OK;
339  }
340  return GNUNET_OK;
341  }
343  {
344  struct GNUNET_HELLO_Builder *b;
345  struct GNUNET_PeerIdentity pid;
346 
348  block_size);
349  if (NULL == b)
350  {
351  GNUNET_break (0);
352  memset (key,
353  0,
354  sizeof (*key));
355  return GNUNET_OK;
356  }
358  &pid,
359  NULL, NULL);
361  sizeof (pid),
362  key);
364  return GNUNET_OK;
365  }
366  default:
367  GNUNET_break (0);
368  return GNUNET_SYSERR;
369  }
370 }
struct GNUNET_HashCode key
The key used in the DHT.

Referenced by libgnunet_plugin_block_dht_init().

Here is the caller graph for this function:

◆ libgnunet_plugin_block_dht_init()

void* libgnunet_plugin_block_dht_init ( void *  cls)

Entry point for the plugin.

Definition at line 377 of file plugin_block_dht.c.

378 {
379  static enum GNUNET_BLOCK_Type types[] = {
382  GNUNET_BLOCK_TYPE_ANY /* end of list */
383  };
384  struct GNUNET_BLOCK_PluginFunctions *api;
385 
392  api->types = types;
393  return api;
394 }
GNUNET_BLOCK_Type
WARNING: This header is generated! In order to add DHT block types, you must register them in GANA,...
@ GNUNET_BLOCK_TYPE_ANY
Identifier for any block.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static enum GNUNET_BLOCK_ReplyEvaluationResult block_plugin_dht_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_dht_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 struct GNUNET_BLOCK_Group * block_plugin_dht_create_group(void *cls, enum GNUNET_BLOCK_Type type, const void *raw_data, size_t raw_data_size, va_list va)
Create a new block group.
static enum GNUNET_GenericReturnValue block_plugin_dht_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_dht_check_block(void *cls, enum GNUNET_BLOCK_Type type, const void *block, size_t block_size)
Function called to validate a block for storage.
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.

References block_plugin_dht_check_block(), block_plugin_dht_check_query(), block_plugin_dht_check_reply(), block_plugin_dht_create_group(), block_plugin_dht_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::get_key, GNUNET_BLOCK_TYPE_ANY, GNUNET_BLOCK_TYPE_DHT_HELLO, GNUNET_BLOCK_TYPE_LEGACY_HELLO, GNUNET_new, and GNUNET_BLOCK_PluginFunctions::types.

Here is the call graph for this function:

◆ libgnunet_plugin_block_dht_done()

void* libgnunet_plugin_block_dht_done ( void *  cls)

Exit point from the plugin.

Definition at line 401 of file plugin_block_dht.c.

402 {
403  struct GNUNET_BLOCK_PluginFunctions *api = cls;
404 
405  GNUNET_free (api);
406  return NULL;
407 }
#define GNUNET_free(ptr)
Wrapper around free.
void * cls
Closure for all of the callbacks.

References GNUNET_BLOCK_PluginFunctions::cls, and GNUNET_free.