GNUnet  0.10.x
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2010-2013 GNUnet e.V.
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
13  Affero General Public License for more details.
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <>.
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
28 #include "platform.h"
29 #include "gnunet_block_group_lib.h"
30 #include "gnunet_block_plugin.h"
32 #include "gnunet_signatures.h"
38 #define BLOOMFILTER_K 16
43 #define GNS_BF_SIZE 8
58 static struct GNUNET_BLOCK_Group *
61  uint32_t nonce,
62  const void *raw_data,
63  size_t raw_data_size,
64  va_list va)
65 {
66  unsigned int bf_size;
67  const char *guard;
69  guard = va_arg(va, const char *);
70  if (0 == strcmp(guard,
71  "seen-set-size"))
72  bf_size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size(va_arg(va, unsigned int),
74  else if (0 == strcmp(guard,
75  "filter-size"))
76  bf_size = va_arg(va, unsigned int);
77  else
78  {
79  GNUNET_break(0);
80  bf_size = GNS_BF_SIZE;
81  }
82  GNUNET_break(NULL == va_arg(va, const char *));
84  bf_size,
86  type,
87  nonce,
88  raw_data,
89  raw_data_size);
90 }
114  struct GNUNET_BLOCK_Context *ctx,
115  enum GNUNET_BLOCK_Type type,
116  struct GNUNET_BLOCK_Group *bg,
118  const struct GNUNET_HashCode *query,
119  const void *xquery,
120  size_t xquery_size,
121  const void *reply_block,
122  size_t reply_block_size)
123 {
124  const struct GNUNET_GNSRECORD_Block *block;
125  struct GNUNET_HashCode h;
126  struct GNUNET_HashCode chash;
130  if (NULL == reply_block)
131  {
132  if (0 != xquery_size)
133  {
134  GNUNET_break_op(0);
136  }
138  }
140  /* this is a reply */
141  if (reply_block_size < sizeof(struct GNUNET_GNSRECORD_Block))
142  {
143  GNUNET_break_op(0);
145  }
146  block = reply_block;
147  if (ntohl(block->purpose.size) + sizeof(struct GNUNET_CRYPTO_EcdsaSignature) + sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey) !=
148  reply_block_size)
149  {
150  GNUNET_break_op(0);
152  }
154  sizeof(block->derived_key),
155  &h);
156  if (0 != GNUNET_memcmp(&h, query))
157  {
158  GNUNET_break_op(0);
160  }
161  if (GNUNET_OK !=
163  {
164  GNUNET_break_op(0);
166  }
167  GNUNET_CRYPTO_hash(reply_block,
168  reply_block_size,
169  &chash);
170  if (GNUNET_YES ==
172  &chash))
175 }
189 static int
191  enum GNUNET_BLOCK_Type type,
192  const void *reply_block,
193  size_t reply_block_size,
194  struct GNUNET_HashCode *key)
195 {
196  const struct GNUNET_GNSRECORD_Block *block;
199  return GNUNET_SYSERR;
200  if (reply_block_size < sizeof(struct GNUNET_GNSRECORD_Block))
201  {
202  GNUNET_break_op(0);
204  }
205  block = reply_block;
207  sizeof(block->derived_key),
208  key);
209  return GNUNET_OK;
210 }
216 void *
218 {
219  static enum GNUNET_BLOCK_Type types[] =
220  {
222  GNUNET_BLOCK_TYPE_ANY /* end of list */
223  };
224  struct GNUNET_BLOCK_PluginFunctions *api;
230  api->types = types;
231  return api;
232 }
238 void *
240 {
241  struct GNUNET_BLOCK_PluginFunctions *api = cls;
243  GNUNET_free(api);
244  return NULL;
245 }
247 /* end of plugin_block_gns.c */
Block does not match query (invalid result)
Handle to an initialized block library.
Definition: block.c:53
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.
static struct GNUNET_BLOCK_Group * block_plugin_gns_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.
Blocks in the datastore and the datacache must have a unique type.
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:173
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
static enum GNUNET_BLOCK_EvaluationResult block_plugin_gns_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.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Information we have in an encrypted block with record data (i.e.
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:248
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
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
void * libgnunet_plugin_block_gns_done(void *cls)
Exit point from the plugin.
an ECC signature using ECDSA
uint32_t size
How many bytes does this signature sign? (including this purpose header); in network byte order (!)...
Block for storing record data.
A 512-bit hashcode.
static int block_plugin_gns_get_key(void *cls, enum GNUNET_BLOCK_Type type, const void *reply_block, size_t reply_block_size, struct GNUNET_HashCode *key)
Function called to obtain the key for a block.
Valid result, and there may be more.
int GNUNET_GNSRECORD_block_verify(const struct GNUNET_GNSRECORD_Block *block)
Check if a signature is valid.
struct GNUNET_HashCode key
The key used in the DHT.
Definition: gnunet_common.h:76
GNUNET_BLOCK_GroupCreateFunction create_group
Create a block group to process a bunch of blocks in a shared context (i.e.
#define GNS_BF_SIZE
How big is the BF we use for GNS blocks?
Possible ways for how a block may relate to a query.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
Specified block type not supported by this plugin.
GNUNET_BLOCK_GetKeyFunction get_key
Obtain the key for a given block (if possible).
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
Query format does not match block type (invalid query).
Number of bits we set per entry in the bloomfilter.
Block group data.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
void * libgnunet_plugin_block_gns_init(void *cls)
Entry point for the plugin.
#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:212
void * cls
Closure for all of the callbacks.
Flags that can be set to control the evaluation.
struct GNUNET_CRYPTO_EccSignaturePurpose purpose
Number of bytes signed; also specifies the number of bytes of encrypted data that follow...
Query is valid, no reply given.
struct GNUNET_CRYPTO_EcdsaPublicKey derived_key
Derived key used for signing; hash of this is the query.
#define GNUNET_free(ptr)
Wrapper around free.