GNUnet  0.11.x
plugin_namestore_flat.c
Go to the documentation of this file.
1 /*
2  * This file is part of GNUnet
3  * Copyright (C) 2009-2015, 2018, 2019 GNUnet e.V.
4  *
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.
9  *
10  * GNUnet is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  * Affero General Public License for more details.
14  *
15  * You should have received a copy of the GNU Affero General Public License
16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
27 #include "platform.h"
30 #include "gnunet_gnsrecord_lib.h"
31 #include "namestore.h"
32 
36 struct Plugin
37 {
38  const struct GNUNET_CONFIGURATION_Handle *cfg;
39 
43  char *fn;
44 
49 };
50 
51 
52 struct FlatFileEntry
53 {
57  struct GNUNET_CRYPTO_EcdsaPrivateKey private_key;
58 
62  uint32_t record_count;
63 
67  uint64_t rvalue;
68 
73 
77  char *label;
78 };
79 
80 
88 static void
90  const char *label,
91  struct GNUNET_HashCode *h)
92 {
93  char *key;
94  size_t label_len;
95  size_t key_len;
96 
97  label_len = strlen (label);
98  key_len = label_len + sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey);
99  key = GNUNET_malloc (key_len);
100  GNUNET_memcpy (key,
101  label,
102  label_len);
103  GNUNET_memcpy (key + label_len,
104  pkey,
105  sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey));
106  GNUNET_CRYPTO_hash (key,
107  key_len,
108  h);
109  GNUNET_free (key);
110 }
111 
112 
121 static int
123 {
124  char *flatdbfile;
125  char *record_data;
126  char *zone_private_key;
127  char *record_data_b64;
128  char *buffer;
129  char *line;
130  char *label;
131  char *rvalue;
132  char *record_count;
133  size_t record_data_size;
134  uint64_t size;
135  struct GNUNET_HashCode hkey;
136  struct GNUNET_DISK_FileHandle *fh;
137  struct FlatFileEntry *entry;
138  struct GNUNET_DISK_MapHandle *mh;
139 
140  if (GNUNET_OK !=
142  "namestore-flat",
143  "FILENAME",
144  &flatdbfile))
145  {
147  "namestore-flat",
148  "FILENAME");
149  return GNUNET_SYSERR;
150  }
151  if (GNUNET_OK !=
152  GNUNET_DISK_file_test (flatdbfile))
153  {
154  if (GNUNET_OK !=
156  {
157  GNUNET_break (0);
158  GNUNET_free (flatdbfile);
159  return GNUNET_SYSERR;
160  }
161  }
162  /* flatdbfile should be UTF-8-encoded. If it isn't, it's a bug */
163  plugin->fn = flatdbfile;
164 
165  /* Load data from file into hashmap */
167  GNUNET_NO);
168  fh = GNUNET_DISK_file_open (flatdbfile,
173  if (NULL == fh)
174  {
176  _ ("Unable to initialize file: %s.\n"),
177  flatdbfile);
178  return GNUNET_SYSERR;
179  }
180  if (GNUNET_SYSERR ==
181  GNUNET_DISK_file_size (flatdbfile,
182  &size,
183  GNUNET_YES,
184  GNUNET_YES))
185  {
187  _ ("Unable to get filesize: %s.\n"),
188  flatdbfile);
190  return GNUNET_SYSERR;
191  }
192  if (size > SIZE_MAX)
193  {
195  _ ("File too big to map: %llu bytes.\n"),
196  (unsigned long long) size);
198  return GNUNET_SYSERR;
199  }
200  if (0 == size)
201  {
203  return GNUNET_OK;
204  }
205  buffer = GNUNET_DISK_file_map (fh,
206  &mh,
208  size);
209  if (NULL == buffer)
210  {
212  "mmap");
214  return GNUNET_SYSERR;
215  }
216  if ('\0' != buffer[size - 1])
217  {
219  _ ("Namestore database file `%s' malformed\n"),
220  flatdbfile);
223  return GNUNET_SYSERR;
224  }
225 
226  line = strtok (buffer, "\n");
227  while (NULL != line)
228  {
229  zone_private_key = strtok (line, ",");
230  if (NULL == zone_private_key)
231  break;
232  rvalue = strtok (NULL, ",");
233  if (NULL == rvalue)
234  break;
235  record_count = strtok (NULL, ",");
236  if (NULL == record_count)
237  break;
238  record_data_b64 = strtok (NULL, ",");
239  if (NULL == record_data_b64)
240  break;
241  label = strtok (NULL, ",");
242  if (NULL == label)
243  break;
244  line = strtok (NULL, "\n");
245  entry = GNUNET_new (struct FlatFileEntry);
246  {
247  unsigned long long ll;
248 
249  if (1 != sscanf (rvalue,
250  "%llu",
251  &ll))
252  {
254  "Error parsing entry\n");
255  GNUNET_free (entry);
256  break;
257  }
258  entry->rvalue = (uint64_t) ll;
259  }
260  {
261  unsigned int ui;
262 
263  if (1 != sscanf (record_count,
264  "%u",
265  &ui))
266  {
268  "Error parsing entry\n");
269  GNUNET_free (entry);
270  break;
271  }
272  entry->record_count = (uint32_t) ui;
273  }
274  entry->label = GNUNET_strdup (label);
275  record_data_size
276  = GNUNET_STRINGS_base64_decode (record_data_b64,
277  strlen (record_data_b64),
278  (void **) &record_data);
279  entry->record_data =
281  struct GNUNET_GNSRECORD_Data);
282  if (GNUNET_OK !=
283  GNUNET_GNSRECORD_records_deserialize (record_data_size,
284  record_data,
285  entry->record_count,
286  entry->record_data))
287  {
289  "Unable to deserialize record %s\n",
290  label);
291  GNUNET_free (entry->label);
292  GNUNET_free (entry);
293  GNUNET_free (record_data);
294  break;
295  }
296  GNUNET_free (record_data);
297 
298  {
299  struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key;
300 
301  GNUNET_STRINGS_base64_decode (zone_private_key,
302  strlen (zone_private_key),
303  (void**) &private_key);
304  entry->private_key = *private_key;
305  GNUNET_free (private_key);
306  }
307 
309  label,
310  &hkey);
311  if (GNUNET_OK !=
313  &hkey,
314  entry,
316  {
317  GNUNET_free (entry);
318  GNUNET_break (0);
319  }
320  }
323  return GNUNET_OK;
324 }
325 
326 
334 static int
336  const struct GNUNET_HashCode *key,
337  void *value)
338 {
339  struct GNUNET_DISK_FileHandle *fh = cls;
340  struct FlatFileEntry *entry = value;
341  char *line;
342  char *zone_private_key;
343  char *record_data_b64;
344  ssize_t data_size;
345 
346  (void) key;
348  sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey),
349  &zone_private_key);
351  entry->record_data);
352  if (data_size < 0)
353  {
354  GNUNET_break (0);
355  GNUNET_free (zone_private_key);
356  return GNUNET_SYSERR;
357  }
358  if (data_size >= UINT16_MAX)
359  {
360  GNUNET_break (0);
361  GNUNET_free (zone_private_key);
362  return GNUNET_SYSERR;
363  }
364  {
365  char data[data_size];
366  ssize_t ret;
367 
369  entry->record_data,
370  data_size,
371  data);
372  if ((ret < 0) ||
373  (data_size != ret))
374  {
375  GNUNET_break (0);
376  GNUNET_free (zone_private_key);
377  return GNUNET_SYSERR;
378  }
380  data_size,
381  &record_data_b64);
382  }
383  GNUNET_asprintf (&line,
384  "%s,%llu,%u,%s,%s\n",
385  zone_private_key,
386  (unsigned long long) entry->rvalue,
387  (unsigned int) entry->record_count,
388  record_data_b64,
389  entry->label);
390  GNUNET_free (record_data_b64);
391  GNUNET_free (zone_private_key);
392 
394  line,
395  strlen (line));
396 
397  GNUNET_free (line);
398  GNUNET_free (entry->label);
399  GNUNET_free (entry->record_data);
400  GNUNET_free (entry);
401  return GNUNET_YES;
402 }
403 
404 
410 static void
412 {
413  struct GNUNET_DISK_FileHandle *fh;
414 
415  fh = GNUNET_DISK_file_open (plugin->fn,
421  if (NULL == fh)
422  {
424  _ ("Unable to initialize file: %s.\n"),
425  plugin->fn);
426  return;
427  }
428 
431  fh);
433  /* append 0-terminator */
435  "",
436  1);
438 }
439 
440 
452 static int
454  const struct
456  const char *label,
457  unsigned int rd_count,
458  const struct GNUNET_GNSRECORD_Data *rd)
459 {
460  struct Plugin *plugin = cls;
461  uint64_t rvalue;
462  struct GNUNET_HashCode hkey;
463  struct FlatFileEntry *entry;
464 
466  UINT64_MAX);
467  hash_pkey_and_label (zone_key,
468  label,
469  &hkey);
471  &hkey);
472  if (0 == rd_count)
473  {
475  "sqlite",
476  "Record deleted\n");
477  return GNUNET_OK;
478  }
479  entry = GNUNET_new (struct FlatFileEntry);
480  GNUNET_asprintf (&entry->label,
481  label,
482  strlen (label));
483  GNUNET_memcpy (&entry->private_key,
484  zone_key,
485  sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey));
486  entry->rvalue = rvalue;
487  entry->record_count = rd_count;
488  entry->record_data = GNUNET_new_array (rd_count,
489  struct GNUNET_GNSRECORD_Data);
490  for (unsigned int i = 0; i < rd_count; i++)
491  {
492  entry->record_data[i].expiration_time = rd[i].expiration_time;
493  entry->record_data[i].record_type = rd[i].record_type;
494  entry->record_data[i].flags = rd[i].flags;
495  entry->record_data[i].data_size = rd[i].data_size;
496  entry->record_data[i].data = GNUNET_malloc (rd[i].data_size);
497  GNUNET_memcpy ((char*) entry->record_data[i].data,
498  rd[i].data,
499  rd[i].data_size);
500  }
501  return GNUNET_CONTAINER_multihashmap_put (plugin->hm,
502  &hkey,
503  entry,
505 }
506 
507 
518 static int
520  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
521  const char *label,
523  void *iter_cls)
524 {
525  struct Plugin *plugin = cls;
526  struct FlatFileEntry *entry;
527  struct GNUNET_HashCode hkey;
528 
529  if (NULL == zone)
530  {
531  GNUNET_break (0);
532  return GNUNET_SYSERR;
533  }
534  hash_pkey_and_label (zone,
535  label,
536  &hkey);
537  entry = GNUNET_CONTAINER_multihashmap_get (plugin->hm,
538  &hkey);
539 
540  if (NULL == entry)
541  return GNUNET_NO;
542  if (NULL != iter)
543  iter (iter_cls,
544  1, /* zero is illegal */
545  &entry->private_key,
546  entry->label,
547  entry->record_count,
548  entry->record_data);
549  return GNUNET_YES;
550 }
551 
552 
557 {
561  uint64_t offset;
562 
566  uint64_t limit;
567 
572  uint64_t pos;
573 
578 
583 
587  void *iter_cls;
588 };
589 
590 
599 static int
600 iterate_zones (void *cls,
601  const struct GNUNET_HashCode *key,
602  void *value)
603 {
604  struct IterateContext *ic = cls;
605  struct FlatFileEntry *entry = value;
606 
607  (void) key;
608  if (0 == ic->limit)
609  return GNUNET_NO;
610  if ((NULL != ic->zone) &&
611  (0 != GNUNET_memcmp (&entry->private_key,
612  ic->zone)))
613  return GNUNET_YES;
614  ic->pos++;
615  if (ic->offset > 0)
616  {
617  ic->offset--;
618  return GNUNET_YES;
619  }
620  ic->iter (ic->iter_cls,
621  ic->pos,
622  (NULL == ic->zone)
623  ? &entry->private_key
624  : ic->zone,
625  entry->label,
626  entry->record_count,
627  entry->record_data);
628  ic->limit--;
629  if (0 == ic->limit)
630  return GNUNET_NO;
631  return GNUNET_YES;
632 }
633 
634 
647 static int
649  const struct
651  uint64_t serial,
652  uint64_t limit,
654  void *iter_cls)
655 {
656  struct Plugin *plugin = cls;
657  struct IterateContext ic;
658 
659  ic.offset = serial;
660  ic.pos = 0;
661  ic.limit = limit;
662  ic.iter = iter;
663  ic.iter_cls = iter_cls;
664  ic.zone = zone;
666  &iterate_zones,
667  &ic);
668  return (0 == ic.limit) ? GNUNET_OK : GNUNET_NO;
669 }
670 
671 
676 {
680  void *iter_cls;
681 
683 };
684 
685 
686 static int
687 zone_to_name (void *cls,
688  const struct GNUNET_HashCode *key,
689  void *value)
690 {
691  struct ZoneToNameContext *ztn = cls;
692  struct FlatFileEntry *entry = value;
693 
694  (void) key;
695  if (0 != GNUNET_memcmp (&entry->private_key,
696  ztn->zone))
697  return GNUNET_YES;
698 
699  for (unsigned int i = 0; i < entry->record_count; i++)
700  {
702  continue;
703  if (0 == memcmp (ztn->value_zone,
704  entry->record_data[i].data,
705  sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)))
706  {
707  ztn->iter (ztn->iter_cls,
708  i + 1, /* zero is illegal! */
709  &entry->private_key,
710  entry->label,
711  entry->record_count,
712  entry->record_data);
713  ztn->result_found = GNUNET_YES;
714  }
715  }
716  return GNUNET_YES;
717 }
718 
719 
731 static int
733  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
734  const struct
735  GNUNET_CRYPTO_EcdsaPublicKey *value_zone,
737  void *iter_cls)
738 {
739  struct Plugin *plugin = cls;
740  struct ZoneToNameContext ztn = {
741  .iter = iter,
742  .iter_cls = iter_cls,
743  .zone = zone,
744  .value_zone = value_zone,
745  .result_found = GNUNET_NO
746  };
747 
749  "Performing reverse lookup for `%s'\n",
750  GNUNET_GNSRECORD_z2s (value_zone));
752  &zone_to_name,
753  &ztn);
754  return ztn.result_found;
755 }
756 
757 
764 void *
766 {
767  static struct Plugin plugin;
768  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
770 
771  if (NULL != plugin.cfg)
772  return NULL; /* can only initialize once! */
773  memset (&plugin,
774  0,
775  sizeof(struct Plugin));
776  plugin.cfg = cfg;
777  if (GNUNET_OK != database_setup (&plugin))
778  {
779  database_shutdown (&plugin);
780  return NULL;
781  }
783  api->cls = &plugin;
789  _ ("Flat file database running\n"));
790  return api;
791 }
792 
793 
800 void *
802 {
804  struct Plugin *plugin = api->cls;
805 
806  database_shutdown (plugin);
807  plugin->cfg = NULL;
808  GNUNET_free (api);
810  "Flat file plugin is finished\n");
811  return NULL;
812 }
813 
814 
815 /* end of plugin_namestore_flat.c */
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:544
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&#39;t exist.
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.
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1345
static char * pkey
Public key of the zone to look in, in ASCII.
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.
void * libgnunet_plugin_namestore_flat_init(void *cls)
Entry point for the plugin.
uint64_t GNUNET_CRYPTO_random_u64(enum GNUNET_CRYPTO_Quality mode, uint64_t max)
Random on unsigned 64-bit values.
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.
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 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?
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
const struct GNUNET_CRYPTO_EcdsaPrivateKey * zone
Target zone.
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
GNUNET_NAMESTORE_RecordIterator iter
char * key
TLS key.
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:1440
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
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_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
uint64_t rvalue
Rvalue.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
int GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:684
#define GNUNET_NO
Definition: gnunet_common.h:78
#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.
void(* GNUNET_NAMESTORE_RecordIterator)(void *cls, uint64_t serial, const struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Function called for each matching record.
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:216
Internal representation of the hash map.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
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.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
Closure for iterate_zones.
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.
uint64_t limit
How many more records should we return?
common internal definitions for namestore service
static char * zone
Name of the zone we manage.
const struct GNUNET_CRYPTO_EcdsaPublicKey * value_zone
void * cls
Closure to pass to all plugin functions.
static uint64_t record_count
Record count.
GNUNET_NAMESTORE_RecordIterator iter
Function to call on each record.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
const void * data
Binary value stored in the DNS record.
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.
static char * value
Value of the record to add/remove.
#define GNUNET_GNSRECORD_TYPE_PKEY
Record type for GNS zone transfer ("PKEY").
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
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:820
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
uint64_t expiration_time
Expiration time for the DNS record.
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.
Closure for zone_to_name.
static int fh
Handle to the unique file.
A 512-bit hashcode.
const char * GNUNET_GNSRECORD_z2s(const struct GNUNET_CRYPTO_EcdsaPublicKey *z)
Convert a zone key to a string (for printing debug messages).
static char * plugin
Solver plugin name as string.
size_t GNUNET_STRINGS_base64_decode(const char *data, size_t len, void **output)
Decode from Base64.
Definition: strings.c:1920
size_t GNUNET_STRINGS_base64_encode(const void *in, size_t len, char **output)
Encode into Base64.
Definition: strings.c:1855
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
int GNUNET_DISK_file_unmap(struct GNUNET_DISK_MapHandle *h)
Unmap a file.
Definition: disk.c:1477
struct GNUNET_CONTAINER_MultiHashMap * hm
HashMap.
void * iter_cls
Iterator cls.
uint32_t record_count
Record cound.
void * iter_cls
Closure for iter.
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.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
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:257
void * libgnunet_plugin_namestore_flat_done(void *cls)
Exit point from the plugin.
char * fn
Filename used for the DB.
const struct GNUNET_CRYPTO_EcdsaPrivateKey * zone
struct GNUNET_GNSRECORD_Data * record_data
Record data.
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.
uint32_t record_type
Type of the GNS/DNS record.
unsigned long long size
Size of all values we&#39;re storing.
configuration data
Definition: configuration.c:85
Handle for a plugin.
Definition: block.c:37
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
#define GNUNET_log(kind,...)
Open the file for both reading and writing.
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 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
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
#define GNUNET_log_from(kind, comp,...)
sqlite3_stmt * zone_to_name
Precompiled SQL to for reverse lookup based on PKEY.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
uint32_t data
The data value.
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:1268
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.
GNUNET_PEERSTORE_Processor iter
Iterator.
struct returned by the initialization function of the plugin
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.
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.
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
#define GNUNET_malloc(size)
Wrapper around malloc.
Handle for a memory-mapping operation.
Definition: disk.c:1412
#define GNUNET_free(ptr)
Wrapper around free.
uint64_t pos
What is the position of the current entry, counting starts from 1.
struct GNUNET_CRYPTO_EcdsaPrivateKey private_key
Entry zone.