file-based namestore backend More...

#include "platform.h"
#include "gnunet_namestore_plugin.h"
#include "gnunet_gnsrecord_lib.h"

Include dependency graph for plugin_namestore_flat.c:

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_BlindablePrivateKey pkey, const char label, struct GNUNET_HashCode *h)
	Hash contactenation of pkey and label into h.

static int	database_setup (struct Plugin *plugin)
	Initialize the database connections and associated data structures (create tables and indices as needed as well).

static int	store_and_free_entries (void cls, const struct GNUNET_HashCode key, void *value)
	Store values in hashmap in file and free data.

static void	database_shutdown (struct Plugin *plugin)
	Shutdown database connection and associate data structures.

static int	namestore_flat_store_records (void cls, const struct GNUNET_CRYPTO_BlindablePrivateKey zone_key, const char label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data rd)
	Store a record in the datastore.

static int	namestore_flat_lookup_records (void cls, const struct GNUNET_CRYPTO_BlindablePrivateKey zone, const char label, GNUNET_NAMESTORE_RecordIterator iter, void iter_cls)
	Lookup records in the datastore for which we are the authority.

static int	iterate_zones (void cls, const struct GNUNET_HashCode key, void *value)
	Helper function for namestore_flat_iterate_records().

static int	namestore_flat_iterate_records (void cls, const struct GNUNET_CRYPTO_BlindablePrivateKey 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 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_BlindablePrivateKey zone, const struct GNUNET_CRYPTO_BlindablePublicKey value_zone, GNUNET_NAMESTORE_RecordIterator iter, void iter_cls)
	Look for an existing PKEY delegation record for a given public key.

void *	libgnunet_plugin_namestore_flat_init (void *cls)
	Entry point for the plugin.

void *	libgnunet_plugin_namestore_flat_done (void *cls)
	Exit point from the plugin.

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_BlindablePrivateKey *	pkey,
		const char *	label,
		struct GNUNET_HashCode *	h
	)

static

Hash contactenation of pkey and label into h.

Parameters

	pkey	a key
	label	a label
[out]	h	initialized hash

Definition at line 87 of file plugin_namestore_flat.c.

{
  char *key;
  size_t label_len;
  size_t key_len;
 
  label_len = strlen (label);
  key_len = label_len + sizeof(struct GNUNET_CRYPTO_BlindablePrivateKey);
  key = GNUNET_malloc (key_len);
  GNUNET_memcpy (key,
                 label,
                 label_len);
  GNUNET_memcpy (key + label_len,
                 pkey,
                 sizeof(struct GNUNET_CRYPTO_BlindablePrivateKey));
  GNUNET_CRYPTO_hash (key,
                      key_len,
                      h);
  GNUNET_free (key);
}

References GNUNET_CRYPTO_hash(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, h, key, and pkey.

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

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

plugin the plugin context (state for this module)

Returns: GNUNET_OK on success

Definition at line 120 of file plugin_namestore_flat.c.

{
  char *flatdbfile;
  char *record_data;
  char *zone_private_key;
  char *record_data_b64;
  char *buffer;
  char *line;
  char *label;
  char *rvalue;
  char *record_count;
  size_t record_data_size;
  uint64_t size;
  struct GNUNET_HashCode hkey;
  struct GNUNET_DISK_FileHandle *fh;
  struct FlatFileEntry *entry;
  struct GNUNET_DISK_MapHandle *mh;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (plugin->cfg,
                                               "namestore-flat",
                                               "FILENAME",
                                               &flatdbfile))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "namestore-flat",
                               "FILENAME");
    return GNUNET_SYSERR;
  }
  if (GNUNET_OK !=
      GNUNET_DISK_file_test (flatdbfile))
  {
    if (GNUNET_OK !=
        GNUNET_DISK_directory_create_for_file (flatdbfile))
    {
      GNUNET_break (0);
      GNUNET_free (flatdbfile);
      return GNUNET_SYSERR;
    }
  }
  /* flatdbfile should be UTF-8-encoded. If it isn't, it's a bug */
  plugin->fn = flatdbfile;
 
  /* Load data from file into hashmap */
  plugin->hm = GNUNET_CONTAINER_multihashmap_create (10,
                                                     GNUNET_NO);
  fh = GNUNET_DISK_file_open (flatdbfile,
                              GNUNET_DISK_OPEN_CREATE
                              | GNUNET_DISK_OPEN_READWRITE,
                              GNUNET_DISK_PERM_USER_WRITE
                              | GNUNET_DISK_PERM_USER_READ);
  if (NULL == fh)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Unable to initialize file: %s.\n"),
                flatdbfile);
    return GNUNET_SYSERR;
  }
  if (GNUNET_SYSERR ==
      GNUNET_DISK_file_size (flatdbfile,
                             &size,
                             GNUNET_YES,
                             GNUNET_YES))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Unable to get filesize: %s.\n"),
                flatdbfile);
    GNUNET_DISK_file_close (fh);
    return GNUNET_SYSERR;
  }
  if (size > SIZE_MAX)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("File too big to map: %llu bytes.\n"),
                (unsigned long long) size);
    GNUNET_DISK_file_close (fh);
    return GNUNET_SYSERR;
  }
  if (0 == size)
  {
    GNUNET_DISK_file_close (fh);
    return GNUNET_OK;
  }
  buffer = GNUNET_DISK_file_map (fh,
                                 &mh,
                                 GNUNET_DISK_MAP_TYPE_READ,
                                 size);
  if (NULL == buffer)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
                         "mmap");
    GNUNET_DISK_file_close (fh);
    return GNUNET_SYSERR;
  }
  if ('\0' != buffer[size - 1])
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Namestore database file `%s' malformed\n"),
                flatdbfile);
    GNUNET_DISK_file_unmap (mh);
    GNUNET_DISK_file_close (fh);
    return GNUNET_SYSERR;
  }
 
  line = strtok (buffer, "\n");
  while (NULL != line)
  {
    zone_private_key = strtok (line, ",");
    if (NULL == zone_private_key)
      break;
    rvalue = strtok (NULL, ",");
    if (NULL == rvalue)
      break;
    record_count = strtok (NULL, ",");
    if (NULL == record_count)
      break;
    record_data_b64 = strtok (NULL, ",");
    if (NULL == record_data_b64)
      break;
    label = strtok (NULL, ",");
    if (NULL == label)
      break;
    line = strtok (NULL, "\n");
    entry = GNUNET_new (struct FlatFileEntry);
    {
      unsigned long long ll;
 
      if (1 != sscanf (rvalue,
                       "%llu",
                       &ll))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Error parsing entry\n");
        GNUNET_free (entry);
        break;
      }
      entry->rvalue = (uint64_t) ll;
    }
    {
      unsigned int ui;
 
      if (1 != sscanf (record_count,
                       "%u",
                       &ui))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Error parsing entry\n");
        GNUNET_free (entry);
        break;
      }
      entry->record_count = (uint32_t) ui;
    }
    entry->label = GNUNET_strdup (label);
    record_data_size
      = GNUNET_STRINGS_base64_decode (record_data_b64,
                                      strlen (record_data_b64),
                                      (void **) &record_data);
    entry->record_data =
      GNUNET_new_array (entry->record_count,
                        struct GNUNET_GNSRECORD_Data);
    if (GNUNET_OK !=
        GNUNET_GNSRECORD_records_deserialize (record_data_size,
                                              record_data,
                                              entry->record_count,
                                              entry->record_data))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Unable to deserialize record %s\n",
                  label);
      GNUNET_free (entry->label);
      GNUNET_free (entry);
      GNUNET_free (record_data);
      break;
    }
    GNUNET_free (record_data);
 
    {
      struct GNUNET_CRYPTO_BlindablePrivateKey *private_key;
 
      GNUNET_STRINGS_base64_decode (zone_private_key,
                                    strlen (zone_private_key),
                                    (void **) &private_key);
      entry->private_key = *private_key;
      GNUNET_free (private_key);
    }
 
    hash_pkey_and_label (&entry->private_key,
                         label,
                         &hkey);
    if (GNUNET_OK !=
        GNUNET_CONTAINER_multihashmap_put (plugin->hm,
                                           &hkey,
                                           entry,
                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
    {
      GNUNET_free (entry);
      GNUNET_break (0);
    }
  }
  GNUNET_DISK_file_unmap (mh);
  GNUNET_DISK_file_close (fh);
  return GNUNET_OK;
}

References _, 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(), FlatFileEntry::label, line, mh, plugin, FlatFileEntry::private_key, record_count, FlatFileEntry::record_count, FlatFileEntry::record_data, FlatFileEntry::rvalue, size, and SIZE_MAX.

Referenced by libgnunet_plugin_namestore_flat_init().

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

plugin	the plugin context
key	key in the map
value	a `struct FlatFileEntry`

Definition at line 333 of file plugin_namestore_flat.c.

{
  struct GNUNET_DISK_FileHandle *fh = cls;
  struct FlatFileEntry *entry = value;
  char *line;
  char *zone_private_key;
  char *record_data_b64;
  ssize_t data_size;
 
  (void) key;
  GNUNET_STRINGS_base64_encode (&entry->private_key,
                                sizeof(struct GNUNET_CRYPTO_BlindablePrivateKey)
                                ,
                                &zone_private_key);
  data_size = GNUNET_GNSRECORD_records_get_size (entry->record_count,
                                                 entry->record_data);
  if (data_size < 0)
  {
    GNUNET_break (0);
    GNUNET_free (zone_private_key);
    return GNUNET_SYSERR;
  }
  if (data_size >= UINT16_MAX)
  {
    GNUNET_break (0);
    GNUNET_free (zone_private_key);
    return GNUNET_SYSERR;
  }
  {
    char data[data_size];
    ssize_t ret;
 
    ret = GNUNET_GNSRECORD_records_serialize (entry->record_count,
                                              entry->record_data,
                                              data_size,
                                              data);
    if ((ret < 0) ||
        (data_size != ret))
    {
      GNUNET_break (0);
      GNUNET_free (zone_private_key);
      return GNUNET_SYSERR;
    }
    GNUNET_STRINGS_base64_encode (data,
                                  data_size,
                                  &record_data_b64);
  }
  GNUNET_asprintf (&line,
                   "%s,%llu,%u,%s,%s\n",
                   zone_private_key,
                   (unsigned long long) entry->rvalue,
                   (unsigned int) entry->record_count,
                   record_data_b64,
                   entry->label);
  GNUNET_free (record_data_b64);
  GNUNET_free (zone_private_key);
 
  GNUNET_DISK_file_write (fh,
                          line,
                          strlen (line));
 
  GNUNET_free (line);
  GNUNET_free (entry->label);
  GNUNET_free (entry->record_data);
  GNUNET_free (entry);
  return GNUNET_YES;
}

References data, data_size, 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, key, FlatFileEntry::label, line, FlatFileEntry::private_key, FlatFileEntry::record_count, FlatFileEntry::record_data, ret, FlatFileEntry::rvalue, and value.

Referenced by database_shutdown().

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

plugin the plugin context (state for this module)

Definition at line 410 of file plugin_namestore_flat.c.

{
  struct GNUNET_DISK_FileHandle *fh;
 
  fh = GNUNET_DISK_file_open (plugin->fn,
                              GNUNET_DISK_OPEN_CREATE
                              | GNUNET_DISK_OPEN_TRUNCATE
                              | GNUNET_DISK_OPEN_READWRITE,
                              GNUNET_DISK_PERM_USER_WRITE
                              | GNUNET_DISK_PERM_USER_READ);
  if (NULL == fh)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Unable to initialize file: %s.\n"),
                plugin->fn);
    return;
  }
 
  GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
                                         &store_and_free_entries,
                                         fh);
  GNUNET_CONTAINER_multihashmap_destroy (plugin->hm);
  /* append 0-terminator */
  GNUNET_DISK_file_write (fh,
                          "",
                          1);
  GNUNET_DISK_file_close (fh);
}

References _, 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, and store_and_free_entries().

Referenced by libgnunet_plugin_namestore_flat_done(), and libgnunet_plugin_namestore_flat_init().

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_BlindablePrivateKey *	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

cls	closure (internal context for the plugin)
zone_key	private key of the zone
label	name that is being mapped (at most 255 characters long)
rd_count	number of entries in rd array
rd	array of records with data to store

Returns: GNUNET_OK on success, else GNUNET_SYSERR

Definition at line 452 of file plugin_namestore_flat.c.

{
  struct Plugin *plugin = cls;
  uint64_t rvalue;
  struct GNUNET_HashCode hkey;
  struct FlatFileEntry *entry;
 
  rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
                                     UINT64_MAX);
  hash_pkey_and_label (zone_key,
                       label,
                       &hkey);
  GNUNET_CONTAINER_multihashmap_remove_all (plugin->hm,
                                            &hkey);
  if (0 == rd_count)
  {
    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                     "sqlite",
                     "Record deleted\n");
    return GNUNET_OK;
  }
  entry = GNUNET_new (struct FlatFileEntry);
  GNUNET_asprintf (&entry->label,
                   label,
                   strlen (label));
  GNUNET_memcpy (&entry->private_key,
                 zone_key,
                 sizeof(struct GNUNET_CRYPTO_BlindablePrivateKey));
  entry->rvalue = rvalue;
  entry->record_count = rd_count;
  entry->record_data = GNUNET_new_array (rd_count,
                                         struct GNUNET_GNSRECORD_Data);
  for (unsigned int i = 0; i < rd_count; i++)
  {
    entry->record_data[i].expiration_time = rd[i].expiration_time;
    entry->record_data[i].record_type = rd[i].record_type;
    entry->record_data[i].flags = rd[i].flags;
    entry->record_data[i].data_size = rd[i].data_size;
    entry->record_data[i].data = GNUNET_malloc (rd[i].data_size);
    GNUNET_memcpy ((char *) entry->record_data[i].data,
                   rd[i].data,
                   rd[i].data_size);
  }
  return GNUNET_CONTAINER_multihashmap_put (plugin->hm,
                                            &hkey,
                                            entry,
                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
}

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(), FlatFileEntry::label, plugin, FlatFileEntry::private_key, rd, rd_count, FlatFileEntry::record_count, FlatFileEntry::record_data, GNUNET_GNSRECORD_Data::record_type, and FlatFileEntry::rvalue.

Referenced by libgnunet_plugin_namestore_flat_init().

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_BlindablePrivateKey *	zone,
		const char *	label,
		GNUNET_NAMESTORE_RecordIterator	iter,
		void *	iter_cls
	)

static

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

Parameters

cls	closure (internal context for the plugin)
zone	private key of the zone
label	name of the record in the zone
iter	function to call with the result
iter_cls	closure for iter

Returns: GNUNET_OK on success, GNUNET_NO for no results, else GNUNET_SYSERR

Definition at line 518 of file plugin_namestore_flat.c.

{
  struct Plugin *plugin = cls;
  struct FlatFileEntry *entry;
  struct GNUNET_HashCode hkey;
 
  if (NULL == zone)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  hash_pkey_and_label (zone,
                       label,
                       &hkey);
  entry = GNUNET_CONTAINER_multihashmap_get (plugin->hm,
                                             &hkey);
 
  if (NULL == entry)
    return GNUNET_NO;
  if (NULL != iter)
    iter (iter_cls,
          1, /* zero is illegal */
          &entry->private_key,
          entry->label,
          entry->record_count,
          entry->record_data);
  return GNUNET_YES;
}

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

Referenced by libgnunet_plugin_namestore_flat_init().

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

cls	a `struct IterateContext`
key	unused
value	a `struct FlatFileEntry`

Returns: GNUNET_YES to continue the iteration

Definition at line 600 of file plugin_namestore_flat.c.

{
  struct IterateContext *ic = cls;
  struct FlatFileEntry *entry = value;
 
  (void) key;
  if (0 == ic->limit)
    return GNUNET_NO;
  if ((NULL != ic->zone) &&
      (0 != GNUNET_memcmp (&entry->private_key,
                           ic->zone)))
    return GNUNET_YES;
  ic->pos++;
  if (ic->offset > 0)
  {
    ic->offset--;
    return GNUNET_YES;
  }
  ic->iter (ic->iter_cls,
            ic->pos,
            (NULL == ic->zone)
            ? &entry->private_key
            : ic->zone,
            entry->label,
            entry->record_count,
            entry->record_data);
  ic->limit--;
  if (0 == ic->limit)
    return GNUNET_NO;
  return GNUNET_YES;
}

References GNUNET_memcmp, GNUNET_NO, GNUNET_YES, IterateContext::iter, IterateContext::iter_cls, key, 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().

Here is the caller graph for this function:

◆ namestore_flat_iterate_records()

static int namestore_flat_iterate_records	(	void *	cls,
		const struct GNUNET_CRYPTO_BlindablePrivateKey *	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

cls	closure (internal context for the plugin)
zone	hash of public key of the zone, NULL to iterate over all zones
serial	serial number to exclude in the list of all matching records
limit	maximum number of results to return to iter
iter	function to call with the result
iter_cls	closure for iter

Returns: GNUNET_OK on success, GNUNET_NO if there were no more results, GNUNET_SYSERR on error

Definition at line 648 of file plugin_namestore_flat.c.

{
  struct Plugin *plugin = cls;
  struct IterateContext ic;
 
  ic.offset = serial;
  ic.pos = 0;
  ic.limit = limit;
  ic.iter = iter;
  ic.iter_cls = iter_cls;
  ic.zone = zone;
  GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
                                         &iterate_zones,
                                         &ic);
  return (0 == ic.limit) ? GNUNET_OK : GNUNET_NO;
}

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

Referenced by libgnunet_plugin_namestore_flat_init().

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 687 of file plugin_namestore_flat.c.

{
  struct ZoneToNameContext *ztn = cls;
  struct FlatFileEntry *entry = value;
 
  (void) key;
  if (0 != GNUNET_memcmp (&entry->private_key,
                          ztn->zone))
    return GNUNET_YES;
 
  for (unsigned int i = 0; i < entry->record_count; i++)
  {
    if (GNUNET_NO ==
        GNUNET_GNSRECORD_is_zonekey_type (entry->record_data[i].record_type))
      continue;
    if (ztn->value_zone->type != entry->record_data[i].record_type)
      continue;
    if (0 == memcmp (ztn->value_zone,
                     entry->record_data[i].data,
                     entry->record_data[i].data_size))
    {
      ztn->iter (ztn->iter_cls,
                 i + 1,    /* zero is illegal! */
                 &entry->private_key,
                 entry->label,
                 entry->record_count,
                 entry->record_data);
      ztn->result_found = GNUNET_YES;
    }
  }
  return GNUNET_YES;
}

References GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, GNUNET_GNSRECORD_is_zonekey_type(), GNUNET_memcmp, GNUNET_NO, GNUNET_YES, ZoneToNameContext::iter, ZoneToNameContext::iter_cls, key, FlatFileEntry::label, FlatFileEntry::private_key, FlatFileEntry::record_count, FlatFileEntry::record_data, GNUNET_GNSRECORD_Data::record_type, ZoneToNameContext::result_found, GNUNET_CRYPTO_BlindablePublicKey::type, value, ZoneToNameContext::value_zone, and ZoneToNameContext::zone.

Referenced by namestore_flat_zone_to_name().

Here is the call graph for this function:

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_BlindablePrivateKey *	zone,
		const struct GNUNET_CRYPTO_BlindablePublicKey *	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

cls	closure (internal context for the plugin)
zone	private key of the zone to look up in, never NULL
value_zone	public key of the target zone (value), never NULL
iter	function to call with the result
iter_cls	closure for iter

Returns: GNUNET_OK on success, GNUNET_NO if there were no results, GNUNET_SYSERR on error

Definition at line 735 of file plugin_namestore_flat.c.

{
  struct Plugin *plugin = cls;
  struct ZoneToNameContext ztn = {
    .iter = iter,
    .iter_cls = iter_cls,
    .zone = zone,
    .value_zone = value_zone,
    .result_found = GNUNET_NO
  };
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Performing reverse lookup for `%s'\n",
              GNUNET_GNSRECORD_z2s (value_zone));
  GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
                                         &zone_to_name,
                                         &ztn);
  return ztn.result_found;
}

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

Referenced by libgnunet_plugin_namestore_flat_init().

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

cls	the "struct GNUNET_NAMESTORE_PluginEnvironment*"

Returns: NULL on error, otherwise the plugin context

Definition at line 769 of file plugin_namestore_flat.c.

{
  static struct Plugin plugin;
  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
  struct GNUNET_NAMESTORE_PluginFunctions *api;
 
  if (NULL != plugin.cfg)
    return NULL;                /* can only initialize once! */
  memset (&plugin,
          0,
          sizeof(struct Plugin));
  plugin.cfg = cfg;
  if (GNUNET_OK != database_setup (&plugin))
  {
    database_shutdown (&plugin);
    return NULL;
  }
  api = GNUNET_new (struct GNUNET_NAMESTORE_PluginFunctions);
  api->cls = &plugin;
  api->store_records = &namestore_flat_store_records;
  api->iterate_records = &namestore_flat_iterate_records;
  api->zone_to_name = &namestore_flat_zone_to_name;
  api->lookup_records = &namestore_flat_lookup_records;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _ ("Flat file database running\n"));
  return api;
}

References _, 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.

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

cls	the plugin context (as returned by "init")

Returns: always NULL

Definition at line 805 of file plugin_namestore_flat.c.

{
  struct GNUNET_NAMESTORE_PluginFunctions *api = cls;
  struct Plugin *plugin = api->cls;
 
  database_shutdown (plugin);
  plugin->cfg = NULL;
  GNUNET_free (api);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Flat file plugin is finished\n");
  return NULL;
}

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

Here is the call graph for this function:

Data Structures

Functions

Detailed Description

Function Documentation

◆ hash_pkey_and_label()

◆ database_setup()

◆ store_and_free_entries()

◆ database_shutdown()

◆ namestore_flat_store_records()

◆ namestore_flat_lookup_records()

◆ iterate_zones()

◆ namestore_flat_iterate_records()

◆ zone_to_name()

◆ namestore_flat_zone_to_name()

◆ libgnunet_plugin_namestore_flat_init()

◆ libgnunet_plugin_namestore_flat_done()