GNUnet  0.10.x
Data Structures | Functions
plugin_namestore_flat.c File Reference

file-based namestore backend More...

#include "platform.h"
#include "gnunet_namestore_plugin.h"
#include "gnunet_namestore_service.h"
#include "gnunet_gnsrecord_lib.h"
#include "namestore.h"
Include dependency graph for plugin_namestore_flat.c:

Go to the source code of this file.

Data Structures

struct  Plugin
 Handle for a plugin. More...
 
struct  FlatFileEntry
 
struct  IterateContext
 Closure for iterate_zones. More...
 
struct  ZoneToNameContext
 Closure for zone_to_name. More...
 

Functions

static void hash_pkey_and_label (const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *label, struct GNUNET_HashCode *h)
 Hash contactenation of pkey and label into h. More...
 
static int database_setup (struct Plugin *plugin)
 Initialize the database connections and associated data structures (create tables and indices as needed as well). More...
 
static int store_and_free_entries (void *cls, const struct GNUNET_HashCode *key, void *value)
 Store values in hashmap in file and free data. More...
 
static void database_shutdown (struct Plugin *plugin)
 Shutdown database connection and associate data structures. More...
 
static int namestore_flat_store_records (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
 Store a record in the datastore. More...
 
static int namestore_flat_lookup_records (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const char *label, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
 Lookup records in the datastore for which we are the authority. More...
 
static int iterate_zones (void *cls, const struct GNUNET_HashCode *key, void *value)
 Helper function for namestore_flat_iterate_records(). More...
 
static int namestore_flat_iterate_records (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, uint64_t serial, uint64_t limit, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
 Iterate over the results for a particular key and zone in the datastore. More...
 
static int zone_to_name (void *cls, const struct GNUNET_HashCode *key, void *value)
 
static int namestore_flat_zone_to_name (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
 Look for an existing PKEY delegation record for a given public key. More...
 
void * libgnunet_plugin_namestore_flat_init (void *cls)
 Entry point for the plugin. More...
 
void * libgnunet_plugin_namestore_flat_done (void *cls)
 Exit point from the plugin. More...
 

Detailed Description

file-based namestore backend

Author
Martin Schanzenbach
Christian Grothoff

Definition in file plugin_namestore_flat.c.

Function Documentation

◆ hash_pkey_and_label()

static void hash_pkey_and_label ( const struct GNUNET_CRYPTO_EcdsaPrivateKey pkey,
const char *  label,
struct GNUNET_HashCode h 
)
static

Hash contactenation of pkey and label into h.

Parameters
pkeya key
labela label
h[out]initialized hash

Definition at line 87 of file plugin_namestore_flat.c.

References GNUNET_CRYPTO_hash(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, and Plugin::key.

Referenced by database_setup(), namestore_flat_lookup_records(), and namestore_flat_store_records().

90 {
91  char *key;
92  size_t label_len;
93  size_t key_len;
94 
95  label_len = strlen(label);
96  key_len = label_len + sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey);
97  key = GNUNET_malloc(key_len);
98  GNUNET_memcpy(key,
99  label,
100  label_len);
101  GNUNET_memcpy(key + label_len,
102  pkey,
103  sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey));
104  GNUNET_CRYPTO_hash(key,
105  key_len,
106  h);
107  GNUNET_free(key);
108 }
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Private ECC key encoded for transmission.
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
struct GNUNET_HashCode key
The key used in the DHT.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ database_setup()

static int database_setup ( struct Plugin plugin)
static

Initialize the database connections and associated data structures (create tables and indices as needed as well).

Parameters
pluginthe plugin context (state for this module)
Returns
GNUNET_OK on success

Definition at line 120 of file plugin_namestore_flat.c.

References _, Plugin::cfg, fh, Plugin::fn, GNUNET_break, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_DISK_directory_create_for_file(), GNUNET_DISK_file_close(), GNUNET_DISK_file_map(), GNUNET_DISK_file_open(), GNUNET_DISK_file_size(), GNUNET_DISK_file_test(), GNUNET_DISK_file_unmap(), GNUNET_DISK_MAP_TYPE_READ, GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_READWRITE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_GNSRECORD_records_deserialize(), GNUNET_log, GNUNET_log_config_missing(), GNUNET_log_strerror, GNUNET_new, GNUNET_new_array, GNUNET_NO, GNUNET_OK, GNUNET_strdup, GNUNET_STRINGS_base64_decode(), GNUNET_SYSERR, GNUNET_YES, hash_pkey_and_label(), Plugin::hm, FlatFileEntry::label, line, mh, FlatFileEntry::private_key, FlatFileEntry::record_count, record_count, FlatFileEntry::record_data, FlatFileEntry::rvalue, Plugin::size, and SIZE_MAX.

Referenced by libgnunet_plugin_namestore_flat_init().

121 {
122  char *flatdbfile;
123  char *record_data;
124  char *zone_private_key;
125  char *record_data_b64;
126  char *buffer;
127  char *line;
128  char *label;
129  char *rvalue;
130  char *record_count;
131  size_t record_data_size;
132  uint64_t size;
133  struct GNUNET_HashCode hkey;
134  struct GNUNET_DISK_FileHandle *fh;
135  struct FlatFileEntry *entry;
136  struct GNUNET_DISK_MapHandle *mh;
137 
138  if (GNUNET_OK !=
140  "namestore-flat",
141  "FILENAME",
142  &flatdbfile))
143  {
145  "namestore-flat",
146  "FILENAME");
147  return GNUNET_SYSERR;
148  }
149  if (GNUNET_OK !=
150  GNUNET_DISK_file_test(flatdbfile))
151  {
152  if (GNUNET_OK !=
154  {
155  GNUNET_break(0);
156  GNUNET_free(flatdbfile);
157  return GNUNET_SYSERR;
158  }
159  }
160  /* flatdbfile should be UTF-8-encoded. If it isn't, it's a bug */
161  plugin->fn = flatdbfile;
162 
163  /* Load data from file into hashmap */
165  GNUNET_NO);
166  fh = GNUNET_DISK_file_open(flatdbfile,
171  if (NULL == fh)
172  {
174  _("Unable to initialize file: %s.\n"),
175  flatdbfile);
176  return GNUNET_SYSERR;
177  }
178  if (GNUNET_SYSERR ==
179  GNUNET_DISK_file_size(flatdbfile,
180  &size,
181  GNUNET_YES,
182  GNUNET_YES))
183  {
185  _("Unable to get filesize: %s.\n"),
186  flatdbfile);
188  return GNUNET_SYSERR;
189  }
190  if (size > SIZE_MAX)
191  {
193  _("File too big to map: %llu bytes.\n"),
194  (unsigned long long)size);
196  return GNUNET_SYSERR;
197  }
198  if (0 == size)
199  {
201  return GNUNET_OK;
202  }
203  buffer = GNUNET_DISK_file_map(fh,
204  &mh,
206  size);
207  if (NULL == buffer)
208  {
210  "mmap");
212  return GNUNET_SYSERR;
213  }
214  if ('\0' != buffer[size - 1])
215  {
217  _("Namestore database file `%s' malformed\n"),
218  flatdbfile);
221  return GNUNET_SYSERR;
222  }
223 
224  line = strtok(buffer, "\n");
225  while (NULL != line)
226  {
227  zone_private_key = strtok(line, ",");
228  if (NULL == zone_private_key)
229  break;
230  rvalue = strtok(NULL, ",");
231  if (NULL == rvalue)
232  break;
233  record_count = strtok(NULL, ",");
234  if (NULL == record_count)
235  break;
236  record_data_b64 = strtok(NULL, ",");
237  if (NULL == record_data_b64)
238  break;
239  label = strtok(NULL, ",");
240  if (NULL == label)
241  break;
242  line = strtok(NULL, "\n");
243  entry = GNUNET_new(struct FlatFileEntry);
244  {
245  unsigned long long ll;
246 
247  if (1 != sscanf(rvalue,
248  "%llu",
249  &ll))
250  {
252  "Error parsing entry\n");
253  GNUNET_free(entry);
254  break;
255  }
256  entry->rvalue = (uint64_t)ll;
257  }
258  {
259  unsigned int ui;
260 
261  if (1 != sscanf(record_count,
262  "%u",
263  &ui))
264  {
266  "Error parsing entry\n");
267  GNUNET_free(entry);
268  break;
269  }
270  entry->record_count = (uint32_t)ui;
271  }
272  entry->label = GNUNET_strdup(label);
273  record_data_size
274  = GNUNET_STRINGS_base64_decode(record_data_b64,
275  strlen(record_data_b64),
276  (void **)&record_data);
277  entry->record_data =
279  struct GNUNET_GNSRECORD_Data);
280  if (GNUNET_OK !=
281  GNUNET_GNSRECORD_records_deserialize(record_data_size,
282  record_data,
283  entry->record_count,
284  entry->record_data))
285  {
287  "Unable to deserialize record %s\n",
288  label);
289  GNUNET_free(entry->label);
290  GNUNET_free(entry);
291  GNUNET_free(record_data);
292  break;
293  }
294  GNUNET_free(record_data);
295 
296  {
297  struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key;
298 
299  GNUNET_STRINGS_base64_decode(zone_private_key,
300  strlen(zone_private_key),
301  (void**)&private_key);
302  entry->private_key = *private_key;
303  GNUNET_free(private_key);
304  }
305 
307  label,
308  &hkey);
309  if (GNUNET_OK !=
311  &hkey,
312  entry,
314  {
315  GNUNET_free(entry);
316  GNUNET_break(0);
317  }
318  }
321  return GNUNET_OK;
322 }
int GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory)...
Definition: disk.c:541
static void hash_pkey_and_label(const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *label, struct GNUNET_HashCode *h)
Hash contactenation of pkey and label into h.
Create file if it doesn't exist.
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1339
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
void * GNUNET_DISK_file_map(const struct GNUNET_DISK_FileHandle *h, struct GNUNET_DISK_MapHandle **m, enum GNUNET_DISK_MapType access, size_t len)
Map a file into memory.
Definition: disk.c:1433
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
uint64_t rvalue
Rvalue.
int GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:681
#define GNUNET_NO
Definition: gnunet_common.h:78
#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.
Private ECC key encoded for transmission.
int GNUNET_GNSRECORD_records_deserialize(size_t len, const char *src, unsigned int rd_count, struct GNUNET_GNSRECORD_Data *dest)
Deserialize the given records to the given destination.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define SIZE_MAX
Definition: platform.h:215
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static uint64_t record_count
Record count.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
static char * line
Desired phone line (string to be converted to a hash).
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
Read-only memory map.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
char * label
Label.
static int fh
Handle to the unique file.
A 512-bit hashcode.
size_t GNUNET_STRINGS_base64_decode(const char *data, size_t len, void **output)
Decode from Base64.
Definition: strings.c:1920
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:66
int GNUNET_DISK_file_unmap(struct GNUNET_DISK_MapHandle *h)
Unmap a file.
Definition: disk.c:1469
struct GNUNET_CONTAINER_MultiHashMap * hm
HashMap.
uint32_t record_count
Record cound.
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
int GNUNET_DISK_file_size(const char *filename, uint64_t *size, int include_symbolic_links, int single_file_mode)
Get the size of the file (or directory) of the given file (in bytes).
Definition: disk.c:254
char * fn
Filename used for the DB.
struct GNUNET_GNSRECORD_Data * record_data
Record data.
#define GNUNET_log(kind,...)
Open the file for both reading and writing.
int GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1262
Handle used to access files (and pipes).
Handle for a memory-mapping operation.
Definition: disk.c:1406
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_CRYPTO_EcdsaPrivateKey private_key
Entry zone.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ store_and_free_entries()

static int store_and_free_entries ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Store values in hashmap in file and free data.

Parameters
pluginthe plugin context
keykey in the map
valuea struct FlatFileEntry

Definition at line 333 of file plugin_namestore_flat.c.

References data, data_size, fh, GNUNET_asprintf(), GNUNET_break, GNUNET_DISK_file_write(), GNUNET_free, GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_records_serialize(), GNUNET_STRINGS_base64_encode(), GNUNET_SYSERR, GNUNET_YES, FlatFileEntry::label, line, FlatFileEntry::private_key, FlatFileEntry::record_count, FlatFileEntry::record_data, ret, FlatFileEntry::rvalue, and value.

Referenced by database_shutdown().

336 {
337  struct GNUNET_DISK_FileHandle *fh = cls;
338  struct FlatFileEntry *entry = value;
339  char *line;
340  char *zone_private_key;
341  char *record_data_b64;
342  ssize_t data_size;
343 
344  (void)key;
346  sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey),
347  &zone_private_key);
349  entry->record_data);
350  if (data_size < 0)
351  {
352  GNUNET_break(0);
353  GNUNET_free(zone_private_key);
354  return GNUNET_SYSERR;
355  }
356  if (data_size >= UINT16_MAX)
357  {
358  GNUNET_break(0);
359  GNUNET_free(zone_private_key);
360  return GNUNET_SYSERR;
361  }
362  {
363  char data[data_size];
364  ssize_t ret;
365 
367  entry->record_data,
368  data_size,
369  data);
370  if ((ret < 0) ||
371  (data_size != ret))
372  {
373  GNUNET_break(0);
374  GNUNET_free(zone_private_key);
375  return GNUNET_SYSERR;
376  }
378  data_size,
379  &record_data_b64);
380  }
381  GNUNET_asprintf(&line,
382  "%s,%llu,%u,%s,%s\n",
383  zone_private_key,
384  (unsigned long long)entry->rvalue,
385  (unsigned int)entry->record_count,
386  record_data_b64,
387  entry->label);
388  GNUNET_free(record_data_b64);
389  GNUNET_free(zone_private_key);
390 
392  line,
393  strlen(line));
394 
395  GNUNET_free(line);
396  GNUNET_free(entry->label);
397  GNUNET_free(entry->record_data);
398  GNUNET_free(entry);
399  return GNUNET_YES;
400 }
GNUNET_NETWORK_STRUCT_END ssize_t GNUNET_GNSRECORD_records_get_size(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Calculate how many bytes we will need to serialize the given records.
ssize_t GNUNET_GNSRECORD_records_serialize(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, size_t dest_size, char *dest)
Serialize the given records to the given destination buffer.
uint64_t rvalue
Rvalue.
Private ECC key encoded for transmission.
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
static char * line
Desired phone line (string to be converted to a hash).
static char * value
Value of the record to add/remove.
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:817
char * label
Label.
static int fh
Handle to the unique file.
size_t GNUNET_STRINGS_base64_encode(const void *in, size_t len, char **output)
Encode into Base64.
Definition: strings.c:1856
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
uint32_t record_count
Record cound.
struct GNUNET_GNSRECORD_Data * record_data
Record data.
#define GNUNET_YES
Definition: gnunet_common.h:77
uint32_t data
The data value.
static size_t data_size
Number of bytes in data.
Handle used to access files (and pipes).
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_CRYPTO_EcdsaPrivateKey private_key
Entry zone.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ database_shutdown()

static void database_shutdown ( struct Plugin plugin)
static

Shutdown database connection and associate data structures.

Parameters
pluginthe plugin context (state for this module)

Definition at line 409 of file plugin_namestore_flat.c.

References _, fh, Plugin::fn, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_write(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_READWRITE, GNUNET_DISK_OPEN_TRUNCATE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, Plugin::hm, and store_and_free_entries().

Referenced by libgnunet_plugin_namestore_flat_done(), and libgnunet_plugin_namestore_flat_init().

410 {
411  struct GNUNET_DISK_FileHandle *fh;
412 
413  fh = GNUNET_DISK_file_open(plugin->fn,
419  if (NULL == fh)
420  {
422  _("Unable to initialize file: %s.\n"),
423  plugin->fn);
424  return;
425  }
426 
429  fh);
431  /* append 0-terminator */
433  "",
434  1);
436 }
Create file if it doesn&#39;t exist.
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1339
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
Truncate file if it exists.
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:817
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
static int fh
Handle to the unique file.
struct GNUNET_CONTAINER_MultiHashMap * hm
HashMap.
char * fn
Filename used for the DB.
#define GNUNET_log(kind,...)
Open the file for both reading and writing.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1262
Handle used to access files (and pipes).
static int store_and_free_entries(void *cls, const struct GNUNET_HashCode *key, void *value)
Store values in hashmap in file and free data.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ namestore_flat_store_records()

static int namestore_flat_store_records ( void *  cls,
const struct GNUNET_CRYPTO_EcdsaPrivateKey zone_key,
const char *  label,
unsigned int  rd_count,
const struct GNUNET_GNSRECORD_Data rd 
)
static

Store a record in the datastore.

Removes any existing record in the same zone with the same name.

Parameters
clsclosure (internal context for the plugin)
zone_keyprivate key of the zone
labelname that is being mapped (at most 255 characters long)
rd_countnumber of entries in rd array
rdarray of records with data to store
Returns
GNUNET_OK on success, else GNUNET_SYSERR

Definition at line 451 of file plugin_namestore_flat.c.

References GNUNET_GNSRECORD_Data::data, data_size, GNUNET_GNSRECORD_Data::data_size, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_asprintf(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_multihashmap_remove_all(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u64(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log_from, GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_new_array, GNUNET_OK, hash_pkey_and_label(), Plugin::hm, FlatFileEntry::label, plugin, FlatFileEntry::private_key, FlatFileEntry::record_count, FlatFileEntry::record_data, GNUNET_GNSRECORD_Data::record_type, and FlatFileEntry::rvalue.

Referenced by libgnunet_plugin_namestore_flat_init().

456 {
457  struct Plugin *plugin = cls;
458  uint64_t rvalue;
459  struct GNUNET_HashCode hkey;
460  struct FlatFileEntry *entry;
461 
463  UINT64_MAX);
464  hash_pkey_and_label(zone_key,
465  label,
466  &hkey);
468  &hkey);
469  if (0 == rd_count)
470  {
472  "sqlite",
473  "Record deleted\n");
474  return GNUNET_OK;
475  }
476  entry = GNUNET_new(struct FlatFileEntry);
477  GNUNET_asprintf(&entry->label,
478  label,
479  strlen(label));
480  GNUNET_memcpy(&entry->private_key,
481  zone_key,
482  sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey));
483  entry->rvalue = rvalue;
484  entry->record_count = rd_count;
485  entry->record_data = GNUNET_new_array(rd_count,
486  struct GNUNET_GNSRECORD_Data);
487  for (unsigned int i = 0; i < rd_count; i++)
488  {
489  entry->record_data[i].expiration_time = rd[i].expiration_time;
490  entry->record_data[i].record_type = rd[i].record_type;
491  entry->record_data[i].flags = rd[i].flags;
492  entry->record_data[i].data_size = rd[i].data_size;
493  entry->record_data[i].data = GNUNET_malloc(rd[i].data_size);
494  GNUNET_memcpy((char*)entry->record_data[i].data,
495  rd[i].data,
496  rd[i].data_size);
497  }
498  return GNUNET_CONTAINER_multihashmap_put(plugin->hm,
499  &hkey,
500  entry,
502 }
static void hash_pkey_and_label(const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *label, struct GNUNET_HashCode *h)
Hash contactenation of pkey and label into h.
uint64_t GNUNET_CRYPTO_random_u64(enum GNUNET_CRYPTO_Quality mode, uint64_t max)
Random on unsigned 64-bit values.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
uint64_t rvalue
Rvalue.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
size_t data_size
Number of bytes in data.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Private ECC key encoded for transmission.
int GNUNET_CONTAINER_multihashmap_remove_all(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Remove all entries for the given key from the map.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
const void * data
Binary value stored in the DNS record.
uint64_t expiration_time
Expiration time for the DNS record.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
char * label
Label.
A 512-bit hashcode.
There must only be one value per key; storing a value should fail if a value under the same key alrea...
struct GNUNET_CONTAINER_MultiHashMap * hm
HashMap.
uint32_t record_count
Record cound.
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_GNSRECORD_Data * record_data
Record data.
uint32_t record_type
Type of the GNS/DNS record.
Handle for a plugin.
Definition: block.c:37
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
#define GNUNET_log_from(kind, comp,...)
static size_t data_size
Number of bytes in data.
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
#define GNUNET_malloc(size)
Wrapper around malloc.
struct GNUNET_CRYPTO_EcdsaPrivateKey private_key
Entry zone.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ namestore_flat_lookup_records()

static int namestore_flat_lookup_records ( void *  cls,
const struct GNUNET_CRYPTO_EcdsaPrivateKey zone,
const char *  label,
GNUNET_NAMESTORE_RecordIterator  iter,
void *  iter_cls 
)
static

Lookup records in the datastore for which we are the authority.

Parameters
clsclosure (internal context for the plugin)
zoneprivate key of the zone
labelname of the record in the zone
iterfunction to call with the result
iter_clsclosure for iter
Returns
GNUNET_OK on success, GNUNET_NO for no results, else GNUNET_SYSERR

Definition at line 516 of file plugin_namestore_flat.c.

References GNUNET_break, GNUNET_CONTAINER_multihashmap_get(), GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, hash_pkey_and_label(), Plugin::hm, Plugin::iter, FlatFileEntry::label, plugin, FlatFileEntry::private_key, FlatFileEntry::record_count, and FlatFileEntry::record_data.

Referenced by libgnunet_plugin_namestore_flat_init().

521 {
522  struct Plugin *plugin = cls;
523  struct FlatFileEntry *entry;
524  struct GNUNET_HashCode hkey;
525 
526  if (NULL == zone)
527  {
528  GNUNET_break(0);
529  return GNUNET_SYSERR;
530  }
531  hash_pkey_and_label(zone,
532  label,
533  &hkey);
534  entry = GNUNET_CONTAINER_multihashmap_get(plugin->hm,
535  &hkey);
536 
537  if (NULL == entry)
538  return GNUNET_NO;
539  if (NULL != iter)
540  iter(iter_cls,
541  1, /* zero is illegal */
542  &entry->private_key,
543  entry->label,
544  entry->record_count,
545  entry->record_data);
546  return GNUNET_YES;
547 }
static void hash_pkey_and_label(const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *label, struct GNUNET_HashCode *h)
Hash contactenation of pkey and label into h.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
char * label
Label.
A 512-bit hashcode.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct GNUNET_CONTAINER_MultiHashMap * hm
HashMap.
uint32_t record_count
Record cound.
struct GNUNET_GNSRECORD_Data * record_data
Record data.
Handle for a plugin.
Definition: block.c:37
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_CRYPTO_EcdsaPrivateKey private_key
Entry zone.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ iterate_zones()

static int iterate_zones ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Helper function for namestore_flat_iterate_records().

Parameters
clsa struct IterateContext
keyunused
valuea struct FlatFileEntry
Returns
GNUNET_YES to continue the iteration

Definition at line 596 of file plugin_namestore_flat.c.

References GNUNET_memcmp, GNUNET_NO, GNUNET_YES, IterateContext::iter, IterateContext::iter_cls, FlatFileEntry::label, IterateContext::limit, IterateContext::offset, IterateContext::pos, FlatFileEntry::private_key, FlatFileEntry::record_count, FlatFileEntry::record_data, value, and IterateContext::zone.

Referenced by namestore_flat_iterate_records().

599 {
600  struct IterateContext *ic = cls;
601  struct FlatFileEntry *entry = value;
602 
603  (void)key;
604  if (0 == ic->limit)
605  return GNUNET_NO;
606  if ((NULL != ic->zone) &&
607  (0 != GNUNET_memcmp(&entry->private_key,
608  ic->zone)))
609  return GNUNET_YES;
610  ic->pos++;
611  if (ic->offset > 0)
612  {
613  ic->offset--;
614  return GNUNET_YES;
615  }
616  ic->iter(ic->iter_cls,
617  ic->pos,
618  (NULL == ic->zone)
619  ? &entry->private_key
620  : ic->zone,
621  entry->label,
622  entry->record_count,
623  entry->record_data);
624  ic->limit--;
625  if (0 == ic->limit)
626  return GNUNET_NO;
627  return GNUNET_YES;
628 }
uint64_t offset
How many more records should we skip before returning results?
const struct GNUNET_CRYPTO_EcdsaPrivateKey * zone
Target zone.
#define GNUNET_NO
Definition: gnunet_common.h:78
Closure for iterate_zones.
uint64_t limit
How many more records should we return?
GNUNET_NAMESTORE_RecordIterator iter
Function to call on each record.
static char * value
Value of the record to add/remove.
char * label
Label.
uint32_t record_count
Record cound.
void * iter_cls
Closure for iter.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
struct GNUNET_GNSRECORD_Data * record_data
Record data.
#define GNUNET_YES
Definition: gnunet_common.h:77
uint64_t pos
What is the position of the current entry, counting starts from 1.
struct GNUNET_CRYPTO_EcdsaPrivateKey private_key
Entry zone.
Here is the caller graph for this function:

◆ namestore_flat_iterate_records()

static int namestore_flat_iterate_records ( void *  cls,
const struct GNUNET_CRYPTO_EcdsaPrivateKey zone,
uint64_t  serial,
uint64_t  limit,
GNUNET_NAMESTORE_RecordIterator  iter,
void *  iter_cls 
)
static

Iterate over the results for a particular key and zone in the datastore.

Will return at most one result to the iterator.

Parameters
clsclosure (internal context for the plugin)
zonehash of public key of the zone, NULL to iterate over all zones
serialserial number to exclude in the list of all matching records
limitmaximum number of results to return to iter
iterfunction to call with the result
iter_clsclosure for iter
Returns
GNUNET_OK on success, GNUNET_NO if there were no more results, GNUNET_SYSERR on error

Definition at line 644 of file plugin_namestore_flat.c.

References GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_NO, GNUNET_OK, Plugin::hm, Plugin::iter, IterateContext::iter, Plugin::iter_cls, IterateContext::iter_cls, iterate_zones(), IterateContext::limit, IterateContext::offset, plugin, IterateContext::pos, zone, and IterateContext::zone.

Referenced by libgnunet_plugin_namestore_flat_init().

650 {
651  struct Plugin *plugin = cls;
652  struct IterateContext ic;
653 
654  ic.offset = serial;
655  ic.pos = 0;
656  ic.limit = limit;
657  ic.iter = iter;
658  ic.iter_cls = iter_cls;
659  ic.zone = zone;
661  &iterate_zones,
662  &ic);
663  return (0 == ic.limit) ? GNUNET_OK : GNUNET_NO;
664 }
static int iterate_zones(void *cls, const struct GNUNET_HashCode *key, void *value)
Helper function for namestore_flat_iterate_records().
uint64_t offset
How many more records should we skip before returning results?
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
Closure for iterate_zones.
uint64_t limit
How many more records should we return?
static char * zone
Name of the zone we manage.
GNUNET_NAMESTORE_RecordIterator iter
Function to call on each record.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
struct GNUNET_CONTAINER_MultiHashMap * hm
HashMap.
void * iter_cls
Closure for iter.
Handle for a plugin.
Definition: block.c:37
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ zone_to_name()

static int zone_to_name ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Definition at line 681 of file plugin_namestore_flat.c.

References GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_memcmp, GNUNET_YES, ZoneToNameContext::iter, ZoneToNameContext::iter_cls, FlatFileEntry::label, FlatFileEntry::private_key, FlatFileEntry::record_count, FlatFileEntry::record_data, GNUNET_GNSRECORD_Data::record_type, ZoneToNameContext::result_found, value, ZoneToNameContext::value_zone, and ZoneToNameContext::zone.

Referenced by run().

684 {
685  struct ZoneToNameContext *ztn = cls;
686  struct FlatFileEntry *entry = value;
687 
688  (void)key;
689  if (0 != GNUNET_memcmp(&entry->private_key,
690  ztn->zone))
691  return GNUNET_YES;
692 
693  for (unsigned int i = 0; i < entry->record_count; i++)
694  {
696  continue;
697  if (0 == memcmp(ztn->value_zone,
698  entry->record_data[i].data,
699  sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)))
700  {
701  ztn->iter(ztn->iter_cls,
702  i + 1, /* zero is illegal! */
703  &entry->private_key,
704  entry->label,
705  entry->record_count,
706  entry->record_data);
707  ztn->result_found = GNUNET_YES;
708  }
709  }
710  return GNUNET_YES;
711 }
GNUNET_NAMESTORE_RecordIterator iter
const struct GNUNET_CRYPTO_EcdsaPublicKey * value_zone
const void * data
Binary value stored in the DNS record.
static char * value
Value of the record to add/remove.
#define GNUNET_GNSRECORD_TYPE_PKEY
Record type for GNS zone transfer ("PKEY").
char * label
Label.
Closure for zone_to_name.
uint32_t record_count
Record cound.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
const struct GNUNET_CRYPTO_EcdsaPrivateKey * zone
struct GNUNET_GNSRECORD_Data * record_data
Record data.
uint32_t record_type
Type of the GNS/DNS record.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_CRYPTO_EcdsaPrivateKey private_key
Entry zone.
Here is the caller graph for this function:

◆ namestore_flat_zone_to_name()

static int namestore_flat_zone_to_name ( void *  cls,
const struct GNUNET_CRYPTO_EcdsaPrivateKey zone,
const struct GNUNET_CRYPTO_EcdsaPublicKey value_zone,
GNUNET_NAMESTORE_RecordIterator  iter,
void *  iter_cls 
)
static

Look for an existing PKEY delegation record for a given public key.

Returns at most one result to the iterator.

Parameters
clsclosure (internal context for the plugin)
zoneprivate key of the zone to look up in, never NULL
value_zonepublic key of the target zone (value), never NULL
iterfunction to call with the result
iter_clsclosure for iter
Returns
GNUNET_OK on success, GNUNET_NO if there were no results, GNUNET_SYSERR on error

Definition at line 726 of file plugin_namestore_flat.c.

References GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_z2s(), GNUNET_log, GNUNET_NO, Plugin::hm, Plugin::iter, ZoneToNameContext::iter, Plugin::iter_cls, plugin, ZoneToNameContext::result_found, ZoneToNameContext::value_zone, zone, and Plugin::zone_to_name.

Referenced by libgnunet_plugin_namestore_flat_init().

731 {
732  struct Plugin *plugin = cls;
733  struct ZoneToNameContext ztn = {
734  .iter = iter,
735  .iter_cls = iter_cls,
736  .zone = zone,
737  .value_zone = value_zone,
738  .result_found = GNUNET_NO
739  };
740 
742  "Performing reverse lookup for `%s'\n",
743  GNUNET_GNSRECORD_z2s(value_zone));
745  &zone_to_name,
746  &ztn);
747  return ztn.result_found;
748 }
GNUNET_NAMESTORE_RecordIterator iter
#define GNUNET_NO
Definition: gnunet_common.h:78
static char * zone
Name of the zone we manage.
const struct GNUNET_CRYPTO_EcdsaPublicKey * value_zone
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
Closure for zone_to_name.
const char * GNUNET_GNSRECORD_z2s(const struct GNUNET_CRYPTO_EcdsaPublicKey *z)
Convert a zone key to a string (for printing debug messages).
struct GNUNET_CONTAINER_MultiHashMap * hm
HashMap.
Handle for a plugin.
Definition: block.c:37
#define GNUNET_log(kind,...)
static int zone_to_name(void *cls, const struct GNUNET_HashCode *key, void *value)
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ libgnunet_plugin_namestore_flat_init()

void* libgnunet_plugin_namestore_flat_init ( void *  cls)

Entry point for the plugin.

Parameters
clsthe "struct GNUNET_NAMESTORE_PluginEnvironment*"
Returns
NULL on error, otherwise the plugin context

Definition at line 758 of file plugin_namestore_flat.c.

References _, Plugin::api, Plugin::cfg, GNUNET_NAMESTORE_PluginFunctions::cls, database_setup(), database_shutdown(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_NAMESTORE_PluginFunctions::iterate_records, GNUNET_NAMESTORE_PluginFunctions::lookup_records, namestore_flat_iterate_records(), namestore_flat_lookup_records(), namestore_flat_store_records(), namestore_flat_zone_to_name(), plugin, GNUNET_NAMESTORE_PluginFunctions::store_records, and GNUNET_NAMESTORE_PluginFunctions::zone_to_name.

759 {
760  static struct Plugin plugin;
761  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
763 
764  if (NULL != plugin.cfg)
765  return NULL; /* can only initialize once! */
766  memset(&plugin,
767  0,
768  sizeof(struct Plugin));
769  plugin.cfg = cfg;
771  {
773  return NULL;
774  }
776  api->cls = &plugin;
782  _("Flat file database running\n"));
783  return api;
784 }
static int namestore_flat_lookup_records(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const char *label, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
Lookup records in the datastore for which we are the authority.
int(* zone_to_name)(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
Look for an existing PKEY delegation record for a given public key.
static int namestore_flat_iterate_records(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, uint64_t serial, uint64_t limit, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
Iterate over the results for a particular key and zone in the datastore.
static void database_shutdown(struct Plugin *plugin)
Shutdown database connection and associate data structures.
#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.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static int namestore_flat_store_records(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Store a record in the datastore.
void * cls
Closure to pass to all plugin functions.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:104
int(* lookup_records)(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const char *label, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
Lookup records in the datastore for which we are the authority.
configuration data
Definition: configuration.c:83
Handle for a plugin.
Definition: block.c:37
#define GNUNET_log(kind,...)
static int database_setup(struct Plugin *plugin)
Initialize the database connections and associated data structures (create tables and indices as need...
static int namestore_flat_zone_to_name(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
Look for an existing PKEY delegation record for a given public key.
int(* store_records)(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Store a record in the datastore for which we are the authority.
struct returned by the initialization function of the plugin
int(* iterate_records)(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, uint64_t serial, uint64_t limit, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
Iterate over the results for a particular zone in the datastore.
Here is the call graph for this function:

◆ libgnunet_plugin_namestore_flat_done()

void* libgnunet_plugin_namestore_flat_done ( void *  cls)

Exit point from the plugin.

Parameters
clsthe plugin context (as returned by "init")
Returns
always NULL

Definition at line 794 of file plugin_namestore_flat.c.

References Plugin::api, Plugin::cfg, GNUNET_NAMESTORE_PluginFunctions::cls, database_shutdown(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, and plugin.

795 {
797  struct Plugin *plugin = api->cls;
798 
799  database_shutdown(plugin);
800  plugin->cfg = NULL;
801  GNUNET_free(api);
803  "Flat file plugin is finished\n");
804  return NULL;
805 }
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
static void database_shutdown(struct Plugin *plugin)
Shutdown database connection and associate data structures.
void * cls
Closure to pass to all plugin functions.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
Handle for a plugin.
Definition: block.c:37
#define GNUNET_log(kind,...)
struct returned by the initialization function of the plugin
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function: