GNUnet  0.10.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 
39  const struct GNUNET_CONFIGURATION_Handle *cfg;
40 
44  char *fn;
45 
50 
51 };
52 
53 
54 struct FlatFileEntry
55 {
59  struct GNUNET_CRYPTO_EcdsaPrivateKey private_key;
60 
64  uint32_t record_count;
65 
69  uint64_t rvalue;
70 
75 
79  char *label;
80 
81 };
82 
83 
91 static void
93  const char *label,
94  struct GNUNET_HashCode *h)
95 {
96  char *key;
97  size_t label_len;
98  size_t key_len;
99 
100  label_len = strlen (label);
101  key_len = label_len + sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey);
102  key = GNUNET_malloc (key_len);
103  GNUNET_memcpy (key,
104  label,
105  label_len);
106  GNUNET_memcpy (key + label_len,
107  pkey,
108  sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey));
109  GNUNET_CRYPTO_hash (key,
110  key_len,
111  h);
112  GNUNET_free (key);
113 }
114 
115 
124 static int
126 {
127  char *flatdbfile;
128  char *record_data;
129  char *zone_private_key;
130  char *record_data_b64;
131  char *buffer;
132  char *line;
133  char *label;
134  char *rvalue;
135  char *record_count;
136  size_t record_data_size;
137  uint64_t size;
138  struct GNUNET_HashCode hkey;
139  struct GNUNET_DISK_FileHandle *fh;
140  struct FlatFileEntry *entry;
141  struct GNUNET_DISK_MapHandle *mh;
142 
143  if (GNUNET_OK !=
145  "namestore-flat",
146  "FILENAME",
147  &flatdbfile))
148  {
150  "namestore-flat",
151  "FILENAME");
152  return GNUNET_SYSERR;
153  }
154  if (GNUNET_OK !=
155  GNUNET_DISK_file_test (flatdbfile))
156  {
157  if (GNUNET_OK !=
159  {
160  GNUNET_break (0);
161  GNUNET_free (flatdbfile);
162  return GNUNET_SYSERR;
163  }
164  }
165  /* flatdbfile should be UTF-8-encoded. If it isn't, it's a bug */
166  plugin->fn = flatdbfile;
167 
168  /* Load data from file into hashmap */
170  GNUNET_NO);
171  fh = GNUNET_DISK_file_open (flatdbfile,
176  if (NULL == fh)
177  {
179  _("Unable to initialize file: %s.\n"),
180  flatdbfile);
181  return GNUNET_SYSERR;
182  }
183  if (GNUNET_SYSERR ==
184  GNUNET_DISK_file_size (flatdbfile,
185  &size,
186  GNUNET_YES,
187  GNUNET_YES))
188  {
190  _("Unable to get filesize: %s.\n"),
191  flatdbfile);
193  return GNUNET_SYSERR;
194  }
195  if (size > SIZE_MAX)
196  {
198  _("File too big to map: %llu bytes.\n"),
199  (unsigned long long) size);
201  return GNUNET_SYSERR;
202  }
203  if (0 == size)
204  {
206  return GNUNET_OK;
207  }
208  buffer = GNUNET_DISK_file_map (fh,
209  &mh,
211  size);
212  if (NULL == buffer)
213  {
215  "mmap");
217  return GNUNET_SYSERR;
218  }
219  if ('\0' != buffer[size-1])
220  {
222  _("Namestore database file `%s' malformed\n"),
223  flatdbfile);
226  return GNUNET_SYSERR;
227  }
228 
229  line = strtok (buffer, "\n");
230  while (NULL != line)
231  {
232  zone_private_key = strtok (line, ",");
233  if (NULL == zone_private_key)
234  break;
235  rvalue = strtok (NULL, ",");
236  if (NULL == rvalue)
237  break;
238  record_count = strtok (NULL, ",");
239  if (NULL == record_count)
240  break;
241  record_data_b64 = strtok (NULL, ",");
242  if (NULL == record_data_b64)
243  break;
244  label = strtok (NULL, ",");
245  if (NULL == label)
246  break;
247  line = strtok (NULL, "\n");
248  entry = GNUNET_new (struct FlatFileEntry);
249  {
250  unsigned long long ll;
251 
252  if (1 != sscanf (rvalue,
253  "%llu",
254  &ll))
255  {
257  "Error parsing entry\n");
258  GNUNET_free (entry);
259  break;
260  }
261  entry->rvalue = (uint64_t) ll;
262  }
263  {
264  unsigned int ui;
265 
266  if (1 != sscanf (record_count,
267  "%u",
268  &ui))
269  {
271  "Error parsing entry\n");
272  GNUNET_free (entry);
273  break;
274  }
275  entry->record_count = (uint32_t) ui;
276  }
277  entry->label = GNUNET_strdup (label);
278  record_data_size
279  = GNUNET_STRINGS_base64_decode (record_data_b64,
280  strlen (record_data_b64),
281  (void **) &record_data);
282  entry->record_data =
284  struct GNUNET_GNSRECORD_Data);
285  if (GNUNET_OK !=
286  GNUNET_GNSRECORD_records_deserialize (record_data_size,
287  record_data,
288  entry->record_count,
289  entry->record_data))
290  {
292  "Unable to deserialize record %s\n",
293  label);
294  GNUNET_free (entry->label);
295  GNUNET_free (entry);
296  GNUNET_free (record_data);
297  break;
298  }
299  GNUNET_free (record_data);
300 
301  {
302  struct GNUNET_CRYPTO_EcdsaPrivateKey *private_key;
303 
304  GNUNET_STRINGS_base64_decode (zone_private_key,
305  strlen (zone_private_key),
306  (void**)&private_key);
307  entry->private_key = *private_key;
308  GNUNET_free (private_key);
309  }
310 
312  label,
313  &hkey);
314  if (GNUNET_OK !=
316  &hkey,
317  entry,
319  {
320  GNUNET_free (entry);
321  GNUNET_break (0);
322  }
323  }
326  return GNUNET_OK;
327 }
328 
329 
337 static int
339  const struct GNUNET_HashCode *key,
340  void *value)
341 {
342  struct GNUNET_DISK_FileHandle *fh = cls;
343  struct FlatFileEntry *entry = value;
344  char *line;
345  char *zone_private_key;
346  char *record_data_b64;
347  ssize_t data_size;
348 
349  (void) key;
351  sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey),
352  &zone_private_key);
354  entry->record_data);
355  if (data_size < 0)
356  {
357  GNUNET_break (0);
358  GNUNET_free (zone_private_key);
359  return GNUNET_SYSERR;
360  }
361  if (data_size >= UINT16_MAX)
362  {
363  GNUNET_break (0);
364  GNUNET_free (zone_private_key);
365  return GNUNET_SYSERR;
366  }
367  {
368  char data[data_size];
369  ssize_t ret;
370 
372  entry->record_data,
373  data_size,
374  data);
375  if ( (ret < 0) ||
376  (data_size != ret) )
377  {
378  GNUNET_break (0);
379  GNUNET_free (zone_private_key);
380  return GNUNET_SYSERR;
381  }
383  data_size,
384  &record_data_b64);
385  }
386  GNUNET_asprintf (&line,
387  "%s,%llu,%u,%s,%s\n",
388  zone_private_key,
389  (unsigned long long) entry->rvalue,
390  (unsigned int) entry->record_count,
391  record_data_b64,
392  entry->label);
393  GNUNET_free (record_data_b64);
394  GNUNET_free (zone_private_key);
395 
397  line,
398  strlen (line));
399 
400  GNUNET_free (line);
401  GNUNET_free (entry->label);
402  GNUNET_free (entry->record_data);
403  GNUNET_free (entry);
404  return GNUNET_YES;
405 }
406 
407 
413 static void
415 {
416  struct GNUNET_DISK_FileHandle *fh;
417 
418  fh = GNUNET_DISK_file_open (plugin->fn,
424  if (NULL == fh)
425  {
427  _("Unable to initialize file: %s.\n"),
428  plugin->fn);
429  return;
430  }
431 
434  fh);
436  /* append 0-terminator */
438  "",
439  1);
441 }
442 
443 
455 static int
457  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
458  const char *label,
459  unsigned int rd_count,
460  const struct GNUNET_GNSRECORD_Data *rd)
461 {
462  struct Plugin *plugin = cls;
463  uint64_t rvalue;
464  struct GNUNET_HashCode hkey;
465  struct FlatFileEntry *entry;
466 
468  UINT64_MAX);
469  hash_pkey_and_label (zone_key,
470  label,
471  &hkey);
473  &hkey);
474  if (0 == rd_count)
475  {
477  "sqlite",
478  "Record deleted\n");
479  return GNUNET_OK;
480  }
481  entry = GNUNET_new (struct FlatFileEntry);
482  GNUNET_asprintf (&entry->label,
483  label,
484  strlen (label));
485  GNUNET_memcpy (&entry->private_key,
486  zone_key,
487  sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey));
488  entry->rvalue = rvalue;
489  entry->record_count = rd_count;
490  entry->record_data = GNUNET_new_array (rd_count,
491  struct GNUNET_GNSRECORD_Data);
492  for (unsigned int i = 0; i < rd_count; i++)
493  {
494  entry->record_data[i].expiration_time = rd[i].expiration_time;
495  entry->record_data[i].record_type = rd[i].record_type;
496  entry->record_data[i].flags = rd[i].flags;
497  entry->record_data[i].data_size = rd[i].data_size;
498  entry->record_data[i].data = GNUNET_malloc (rd[i].data_size);
499  GNUNET_memcpy ((char*)entry->record_data[i].data,
500  rd[i].data,
501  rd[i].data_size);
502  }
503  return GNUNET_CONTAINER_multihashmap_put (plugin->hm,
504  &hkey,
505  entry,
507 }
508 
509 
520 static int
522  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
523  const char *label,
525  void *iter_cls)
526 {
527  struct Plugin *plugin = cls;
528  struct FlatFileEntry *entry;
529  struct GNUNET_HashCode hkey;
530 
531  if (NULL == zone)
532  {
533  GNUNET_break (0);
534  return GNUNET_SYSERR;
535  }
536  hash_pkey_and_label (zone,
537  label,
538  &hkey);
539  entry = GNUNET_CONTAINER_multihashmap_get (plugin->hm,
540  &hkey);
541 
542  if (NULL == entry)
543  return GNUNET_NO;
544  if (NULL != iter)
545  iter (iter_cls,
546  1, /* zero is illegal */
547  &entry->private_key,
548  entry->label,
549  entry->record_count,
550  entry->record_data);
551  return GNUNET_YES;
552 }
553 
554 
559 {
563  uint64_t offset;
564 
568  uint64_t limit;
569 
574  uint64_t pos;
575 
580 
585 
589  void *iter_cls;
590 
591 };
592 
593 
602 static int
603 iterate_zones (void *cls,
604  const struct GNUNET_HashCode *key,
605  void *value)
606 {
607  struct IterateContext *ic = cls;
608  struct FlatFileEntry *entry = value;
609 
610  (void) key;
611  if (0 == ic->limit)
612  return GNUNET_NO;
613  if ( (NULL != ic->zone) &&
614  (0 != GNUNET_memcmp (&entry->private_key,
615  ic->zone)) )
616  return GNUNET_YES;
617  ic->pos++;
618  if (ic->offset > 0)
619  {
620  ic->offset--;
621  return GNUNET_YES;
622  }
623  ic->iter (ic->iter_cls,
624  ic->pos,
625  (NULL == ic->zone)
626  ? &entry->private_key
627  : ic->zone,
628  entry->label,
629  entry->record_count,
630  entry->record_data);
631  ic->limit--;
632  if (0 == ic->limit)
633  return GNUNET_NO;
634  return GNUNET_YES;
635 }
636 
637 
650 static int
652  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
653  uint64_t serial,
654  uint64_t limit,
656  void *iter_cls)
657 {
658  struct Plugin *plugin = cls;
659  struct IterateContext ic;
660 
661  ic.offset = serial;
662  ic.pos = 0;
663  ic.limit = limit;
664  ic.iter = iter;
665  ic.iter_cls = iter_cls;
666  ic.zone = zone;
668  &iterate_zones,
669  &ic);
670  return (0 == ic.limit) ? GNUNET_OK : GNUNET_NO;
671 }
672 
673 
678 {
682  void *iter_cls;
683 
685 };
686 
687 
688 static int
689 zone_to_name (void *cls,
690  const struct GNUNET_HashCode *key,
691  void *value)
692 {
693  struct ZoneToNameContext *ztn = cls;
694  struct FlatFileEntry *entry = value;
695 
696  (void) key;
697  if (0 != GNUNET_memcmp (&entry->private_key,
698  ztn->zone))
699  return GNUNET_YES;
700 
701  for (unsigned int i = 0; i < entry->record_count; i++)
702  {
704  continue;
705  if (0 == memcmp (ztn->value_zone,
706  entry->record_data[i].data,
707  sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
708  {
709  ztn->iter (ztn->iter_cls,
710  i + 1, /* zero is illegal! */
711  &entry->private_key,
712  entry->label,
713  entry->record_count,
714  entry->record_data);
715  ztn->result_found = GNUNET_YES;
716  }
717  }
718  return GNUNET_YES;
719 }
720 
721 
733 static int
735  const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
736  const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone,
738  void *iter_cls)
739 {
740  struct Plugin *plugin = cls;
741  struct ZoneToNameContext ztn = {
742  .iter = iter,
743  .iter_cls = iter_cls,
744  .zone = zone,
745  .value_zone = value_zone,
746  .result_found = GNUNET_NO
747  };
748 
750  "Performing reverse lookup for `%s'\n",
751  GNUNET_GNSRECORD_z2s (value_zone));
753  &zone_to_name,
754  &ztn);
755  return ztn.result_found;
756 }
757 
758 
765 void *
767 {
768  static struct Plugin plugin;
769  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
771 
772  if (NULL != plugin.cfg)
773  return NULL; /* can only initialize once! */
774  memset (&plugin,
775  0,
776  sizeof (struct Plugin));
777  plugin.cfg = cfg;
778  if (GNUNET_OK != database_setup (&plugin))
779  {
780  database_shutdown (&plugin);
781  return NULL;
782  }
784  api->cls = &plugin;
790  _("Flat file database running\n"));
791  return api;
792 }
793 
794 
801 void *
803 {
805  struct Plugin *plugin = api->cls;
806 
807  database_shutdown (plugin);
808  plugin->cfg = NULL;
809  GNUNET_free (api);
811  "Flat file plugin is finished\n");
812  return NULL;
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:669
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:1817
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?
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:2020
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.
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:833
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
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.
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define SIZE_MAX
Definition: platform.h:250
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:94
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:208
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.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
#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.
#define GNUNET_memcpy(dst, src, n)
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:44
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:1049
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).
size_t GNUNET_STRINGS_base64_decode(const char *data, size_t len, void **output)
Decode from Base64.
Definition: strings.c:2067
size_t GNUNET_STRINGS_base64_encode(const void *in, size_t len, char **output)
Encode into Base64.
Definition: strings.c:2004
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:79
int GNUNET_DISK_file_unmap(struct GNUNET_DISK_MapHandle *h)
Unmap a file.
Definition: disk.c:2100
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:289
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:80
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:1673
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.
static size_t data_size
Number of bytes in data.
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:1985
#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.