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

blocks used for file-sharing More...

#include "platform.h"
#include "gnunet_block_plugin.h"
#include "gnunet_fs_service.h"
#include "block_fs.h"
#include "gnunet_signatures.h"
#include "gnunet_block_group_lib.h"
Include dependency graph for plugin_block_fs.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...
 

Functions

static struct GNUNET_BLOCK_Groupblock_plugin_fs_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 block_plugin_fs_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_fs_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_fs_init (void *cls)
 Entry point for the plugin. More...
 
void * libgnunet_plugin_block_fs_done (void *cls)
 Exit point from the plugin. More...
 

Detailed Description

blocks used for file-sharing

Author
Christian Grothoff

Definition in file plugin_block_fs.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_fs.c.

Referenced by block_plugin_fs_create_group().

Function Documentation

◆ block_plugin_fs_create_group()

static struct GNUNET_BLOCK_Group* block_plugin_fs_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 54 of file plugin_block_fs.c.

References BLOOMFILTER_K, GNUNET_BLOCK_GROUP_bf_create(), GNUNET_BLOCK_GROUP_compute_bloomfilter_size(), GNUNET_BLOCK_TYPE_FS_DBLOCK, GNUNET_BLOCK_TYPE_FS_IBLOCK, GNUNET_BLOCK_TYPE_FS_UBLOCK, GNUNET_break, and size.

Referenced by libgnunet_plugin_block_fs_init().

60 {
61  unsigned int size;
62  const char *guard;
63 
64  switch (type)
65  {
67  GNUNET_break (NULL == va_arg (va, const char *));
68  return NULL;
69 
71  GNUNET_break (NULL == va_arg (va, const char *));
72  return NULL;
73 
75  guard = va_arg (va, const char *);
76  if (0 == strcmp (guard,
77  "seen-set-size"))
78  {
79  size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size (va_arg (va, unsigned
80  int),
82  }
83  else if (0 == strcmp (guard,
84  "filter-size"))
85  {
86  size = va_arg (va, unsigned int);
87  }
88  else
89  {
90  /* va-args invalid! bad bug, complain! */
91  GNUNET_break (0);
92  size = 8;
93  }
94  if (0 == size)
95  size = raw_data_size; /* not for us to determine, use what we got! */
96  GNUNET_break (NULL == va_arg (va, const char *));
97  return GNUNET_BLOCK_GROUP_bf_create (cls,
98  size,
100  type,
101  nonce,
102  raw_data,
103  raw_data_size);
104 
105  default:
106  GNUNET_break (NULL == va_arg (va, const char *));
107  GNUNET_break (0);
108  return NULL;
109  }
110 }
#define BLOOMFILTER_K
Number of bits we set per entry in the bloomfilter.
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
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...
Inner block in the CHK tree.
Type of a block representing any type of search result (universal).
static unsigned int size
Size of the "table".
Definition: peer.c:67
Data block (leaf) in the CHK tree.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
Here is the call graph for this function:
Here is the caller graph for this function:

◆ block_plugin_fs_evaluate()

static enum GNUNET_BLOCK_EvaluationResult block_plugin_fs_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 use for evaluation
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 133 of file plugin_block_fs.c.

References GNUNET_BLOCK_EO_LOCAL_SKIP_CRYPTO, GNUNET_BLOCK_EVALUATION_OK_DUPLICATE, GNUNET_BLOCK_EVALUATION_OK_LAST, GNUNET_BLOCK_EVALUATION_OK_MORE, GNUNET_BLOCK_EVALUATION_REQUEST_INVALID, GNUNET_BLOCK_EVALUATION_REQUEST_VALID, GNUNET_BLOCK_EVALUATION_RESULT_INVALID, GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED, GNUNET_BLOCK_GROUP_bf_test_and_set(), GNUNET_BLOCK_TYPE_FS_DBLOCK, GNUNET_BLOCK_TYPE_FS_IBLOCK, GNUNET_BLOCK_TYPE_FS_UBLOCK, GNUNET_break_op, GNUNET_CRYPTO_ecdsa_verify(), GNUNET_CRYPTO_hash(), GNUNET_OK, GNUNET_SIGNATURE_PURPOSE_FS_UBLOCK, GNUNET_YES, UBlock::purpose, UBlock::signature, GNUNET_CRYPTO_EccSignaturePurpose::size, and UBlock::verification_key.

Referenced by libgnunet_plugin_block_fs_init().

143 {
144  const struct UBlock *ub;
145  struct GNUNET_HashCode hc;
146  struct GNUNET_HashCode chash;
147 
148  switch (type)
149  {
152  if (0 != xquery_size)
153  {
154  GNUNET_break_op (0);
156  }
157  if (NULL == reply_block)
160 
162  if (0 != xquery_size)
163  {
164  GNUNET_break_op (0);
166  }
167  if (NULL == reply_block)
169 
170  if (reply_block_size < sizeof(struct UBlock))
171  {
172  GNUNET_break_op (0);
174  }
175  ub = reply_block;
177  sizeof(ub->verification_key),
178  &hc);
179  if (0 != memcmp (&hc,
180  query,
181  sizeof(struct GNUNET_HashCode)))
182  {
183  GNUNET_break_op (0);
185  }
186  if (reply_block_size != ntohl (ub->purpose.size) + sizeof(struct
188  {
189  GNUNET_break_op (0);
191  }
192  if ((0 == (eo & GNUNET_BLOCK_EO_LOCAL_SKIP_CRYPTO)) &&
193  (GNUNET_OK !=
195  &ub->purpose,
196  &ub->signature,
197  &ub->verification_key)))
198  {
199  GNUNET_break_op (0);
201  }
202  GNUNET_CRYPTO_hash (reply_block,
203  reply_block_size,
204  &chash);
205  if (GNUNET_YES ==
207  &chash))
210 
211  default:
213  }
214 }
Block does not match query (invalid result)
int GNUNET_CRYPTO_ecdsa_verify(uint32_t purpose, const struct GNUNET_CRYPTO_EccSignaturePurpose *validate, const struct GNUNET_CRYPTO_EcdsaSignature *sig, const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Verify ECDSA signature.
Definition: crypto_ecc.c:1045
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_SIGNATURE_PURPOSE_FS_UBLOCK
UBlock Signature, done using DSS, not ECC.
struct GNUNET_CRYPTO_EcdsaSignature signature
Signature using pseudonym and search keyword / identifier.
Definition: block_fs.h:54
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:48
Inner block in the CHK tree.
Last possible valid result.
an ECC signature using ECDSA
uint32_t size
How many bytes does this signature sign? (including this purpose header); in network byte order (!)...
Type of a block representing any type of search result (universal).
A 512-bit hashcode.
The block is obtained from the local database, skip cryptographic checks.
Valid result, and there may be more.
Specified block type not supported by this plugin.
Query format does not match block type (invalid query).
Data block (leaf) in the CHK tree.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
#define GNUNET_YES
Definition: gnunet_common.h:77
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
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
What is being signed and why?
Definition: block_fs.h:59
Query is valid, no reply given.
struct GNUNET_CRYPTO_EcdsaPublicKey verification_key
Public key used to sign this block.
Definition: block_fs.h:64
universal block for keyword and namespace search results
Definition: block_fs.h:49
Here is the call graph for this function:
Here is the caller graph for this function:

◆ block_plugin_fs_get_key()

static int block_plugin_fs_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 229 of file plugin_block_fs.c.

References GNUNET_BLOCK_TYPE_FS_DBLOCK, GNUNET_BLOCK_TYPE_FS_IBLOCK, GNUNET_BLOCK_TYPE_FS_UBLOCK, GNUNET_break, GNUNET_CRYPTO_hash(), GNUNET_OK, GNUNET_SYSERR, and UBlock::verification_key.

Referenced by libgnunet_plugin_block_fs_init().

234 {
235  const struct UBlock *ub;
236 
237  switch (type)
238  {
241  GNUNET_CRYPTO_hash (block, block_size, key);
242  return GNUNET_OK;
243 
245  if (block_size < sizeof(struct UBlock))
246  {
247  GNUNET_break (0);
248  return GNUNET_SYSERR;
249  }
250  ub = block;
252  sizeof(ub->verification_key),
253  key);
254  return GNUNET_OK;
255 
256  default:
257  GNUNET_break (0);
258  return GNUNET_SYSERR;
259  }
260 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
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
Inner block in the CHK tree.
Type of a block representing any type of search result (universal).
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
Data block (leaf) in the CHK tree.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
struct GNUNET_CRYPTO_EcdsaPublicKey verification_key
Public key used to sign this block.
Definition: block_fs.h:64
universal block for keyword and namespace search results
Definition: block_fs.h:49
Here is the call graph for this function:
Here is the caller graph for this function:

◆ libgnunet_plugin_block_fs_init()

void* libgnunet_plugin_block_fs_init ( void *  cls)

Entry point for the plugin.

Definition at line 267 of file plugin_block_fs.c.

References block_plugin_fs_create_group(), block_plugin_fs_evaluate(), block_plugin_fs_get_key(), GNUNET_BLOCK_PluginFunctions::create_group, GNUNET_BLOCK_PluginFunctions::evaluate, GNUNET_BLOCK_PluginFunctions::get_key, GNUNET_BLOCK_TYPE_ANY, GNUNET_BLOCK_TYPE_FS_DBLOCK, GNUNET_BLOCK_TYPE_FS_IBLOCK, GNUNET_BLOCK_TYPE_FS_UBLOCK, GNUNET_new, and GNUNET_BLOCK_PluginFunctions::types.

268 {
269  static enum GNUNET_BLOCK_Type types[] = {
273  GNUNET_BLOCK_TYPE_ANY /* end of list */
274  };
275  struct GNUNET_BLOCK_PluginFunctions *api;
276 
281  api->types = types;
282  return api;
283 }
enum GNUNET_BLOCK_Type * types
0-terminated array of block types supported by this plugin.
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.
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 int block_plugin_fs_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_BLOCK_EvaluationResult block_plugin_fs_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.
Inner block in the CHK tree.
Type of a block representing any type of search result (universal).
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).
Data block (leaf) in the CHK tree.
static struct GNUNET_BLOCK_Group * block_plugin_fs_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.
Here is the call graph for this function:

◆ libgnunet_plugin_block_fs_done()

void* libgnunet_plugin_block_fs_done ( void *  cls)

Exit point from the plugin.

Definition at line 290 of file plugin_block_fs.c.

References GNUNET_BLOCK_PluginFunctions::cls, and GNUNET_free.

291 {
292  struct GNUNET_BLOCK_PluginFunctions *api = cls;
293 
294  GNUNET_free (api);
295  return NULL;
296 }
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.