plugin_namecache_flat.c File Reference

flat file-based namecache backend More...

#include "platform.h"
#include "gnunet_namecache_plugin.h"
#include "gnunet_namecache_service.h"
#include "gnunet_gnsrecord_lib.h"

Include dependency graph for plugin_namecache_flat.c:

Go to the source code of this file.

Data Structures
struct	Plugin
	Handle for a plugin. More...
struct	FlatFileEntry

Functions
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	expire_blocks (void *cls, const struct GNUNET_HashCode *key, void *value)
static void	namecache_expire_blocks (struct Plugin *plugin)
	Removes any expired block. More...
static int	namecache_cache_block (void *cls, const struct GNUNET_GNSRECORD_Block *block)
	Cache a block in the datastore. More...
static int	namecache_lookup_block (void *cls, const struct GNUNET_HashCode *query, GNUNET_NAMECACHE_BlockCallback iter, void *iter_cls)
	Get the block for a particular zone and label in the datastore. More...
void *	libgnunet_plugin_namecache_flat_init (void *cls)
	Entry point for the plugin. More...
void *	libgnunet_plugin_namecache_flat_done (void *cls)
	Exit point from the plugin. More...

Detailed Description

flat file-based namecache backend

Author

Martin Schanzenbach

Definition in file plugin_namecache_flat.c.

Function Documentation

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 72 of file plugin_namecache_flat.c.

{
  char *afsdir;
  char*block_buffer;
  char*buffer;
  char*line;
  char*query;
  char*block;
  uint64_t size;
  struct FlatFileEntry *entry;
  struct GNUNET_DISK_FileHandle *fh;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (plugin->cfg,
                                               "namecache-flat",
                                               "FILENAME",
                                               &afsdir))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "namecache-flat", "FILENAME");
    return GNUNET_SYSERR;
  }
  if (GNUNET_OK != GNUNET_DISK_file_test (afsdir))
  {
    if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (afsdir))
    {
      GNUNET_break (0);
      GNUNET_free (afsdir);
      return GNUNET_SYSERR;
    }
  }
  /* afsdir should be UTF-8-encoded. If it isn't, it's a bug */
  plugin->fn = afsdir;
 
  /* Load data from file into hashmap */
  plugin->hm = GNUNET_CONTAINER_multihashmap_create (10,
                                                     GNUNET_NO);
  fh = GNUNET_DISK_file_open (afsdir,
                              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"),
                afsdir);
    return GNUNET_SYSERR;
  }
 
  if (GNUNET_SYSERR == GNUNET_DISK_file_size (afsdir,
                                              &size,
                                              GNUNET_YES,
                                              GNUNET_YES))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Unable to get filesize: %s.\n"),
                afsdir);
    GNUNET_DISK_file_close (fh);
    return GNUNET_SYSERR;
  }
 
  if (0 == size)
  {
    GNUNET_DISK_file_close (fh);
    return GNUNET_OK;
  }
 
  buffer = GNUNET_malloc (size + 1);
 
  if (GNUNET_SYSERR == GNUNET_DISK_file_read (fh,
                                              buffer,
                                              size))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Unable to read file: %s.\n"),
                afsdir);
    GNUNET_free (buffer);
    GNUNET_DISK_file_close (fh);
    return GNUNET_SYSERR;
  }
  buffer[size] = '\0';
 
  GNUNET_DISK_file_close (fh);
  if (0 < size)
  {
    line = strtok (buffer, "\n");
    while (line != NULL)
    {
      query = strtok (line, ",");
      if (NULL == query)
        break;
      block = strtok (NULL, ",");
      if (NULL == block)
        break;
      line = strtok (NULL, "\n");
      entry = GNUNET_malloc (sizeof(struct FlatFileEntry));
      GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_hash_from_string (query,
                                                                  &entry->query));
      GNUNET_STRINGS_base64_decode (block,
                                    strlen (block),
                                    (void **) &block_buffer);
      entry->block = (struct GNUNET_GNSRECORD_Block *) block_buffer;
      if (GNUNET_OK !=
          GNUNET_CONTAINER_multihashmap_put (plugin->hm,
                                             &entry->query,
                                             entry,
                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
      {
        GNUNET_free (entry);
        GNUNET_break (0);
      }
    }
  }
  GNUNET_free (buffer);
  return GNUNET_OK;
}

References _, FlatFileEntry::block, GNUNET_assert, GNUNET_break, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_hash_from_string, GNUNET_DISK_directory_create_for_file(), GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_read(), GNUNET_DISK_file_size(), GNUNET_DISK_file_test(), 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_log, GNUNET_log_config_missing(), GNUNET_malloc, GNUNET_NO, GNUNET_OK, GNUNET_STRINGS_base64_decode(), GNUNET_SYSERR, GNUNET_YES, line, plugin, FlatFileEntry::query, and size.

Referenced by libgnunet_plugin_namecache_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

Definition at line 197 of file plugin_namecache_flat.c.

{
  struct GNUNET_DISK_FileHandle *fh = cls;
  struct FlatFileEntry *entry = value;
 
  char *line;
  char *block_b64;
  struct GNUNET_CRYPTO_HashAsciiEncoded query;
  size_t block_size;
 
  block_size = GNUNET_GNSRECORD_block_get_size (entry->block);
  GNUNET_STRINGS_base64_encode ((char *) entry->block,
                                block_size,
                                &block_b64);
  GNUNET_CRYPTO_hash_to_enc (&entry->query,
                             &query);
  GNUNET_asprintf (&line,
                   "%s,%s\n",
                   (char *) &query,
                   block_b64);
 
  GNUNET_free (block_b64);
 
  GNUNET_DISK_file_write (fh,
                          line,
                          strlen (line));
 
  GNUNET_free (entry->block);
  GNUNET_free (entry);
  GNUNET_free (line);
  return GNUNET_YES;
}

References FlatFileEntry::block, GNUNET_asprintf(), GNUNET_CRYPTO_hash_to_enc(), GNUNET_DISK_file_write(), GNUNET_free, GNUNET_GNSRECORD_block_get_size(), GNUNET_STRINGS_base64_encode(), GNUNET_YES, line, FlatFileEntry::query, 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 239 of file plugin_namecache_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);
  GNUNET_DISK_file_close (fh);
}

References _, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), 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_namecache_flat_done(), and libgnunet_plugin_namecache_flat_init().

Here is the call graph for this function:

Here is the caller graph for this function:

expire_blocks()

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

static

Definition at line 266 of file plugin_namecache_flat.c.

{
  struct Plugin *plugin = cls;
  struct FlatFileEntry *entry = value;
  struct GNUNET_TIME_Absolute now;
  struct GNUNET_TIME_Absolute expiration;
 
  now = GNUNET_TIME_absolute_get ();
  expiration = GNUNET_GNSRECORD_block_get_expiration (entry->block);
 
  if (0 == GNUNET_TIME_absolute_get_difference (now,
                                                expiration).rel_value_us)
  {
    GNUNET_CONTAINER_multihashmap_remove_all (plugin->hm, key);
  }
  return GNUNET_YES;
}

References FlatFileEntry::block, expiration, GNUNET_CONTAINER_multihashmap_remove_all(), GNUNET_GNSRECORD_block_get_expiration(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_difference(), GNUNET_YES, key, plugin, and value.

Referenced by namecache_expire_blocks().

Here is the call graph for this function:

Here is the caller graph for this function:

namecache_expire_blocks()

static void namecache_expire_blocks ( struct Plugin *  plugin )

static

Removes any expired block.

Parameters

plugin

the plugin

Definition at line 293 of file plugin_namecache_flat.c.

{
  GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
                                         &expire_blocks,
                                         plugin);
}

References expire_blocks(), GNUNET_CONTAINER_multihashmap_iterate(), and plugin.

Referenced by namecache_cache_block().

Here is the call graph for this function:

Here is the caller graph for this function:

namecache_cache_block()

static int namecache_cache_block ( void *  cls, const struct GNUNET_GNSRECORD_Block *  block  )

static

Cache a block in the datastore.

Parameters

cls	closure (internal context for the plugin)
block	block to cache

Returns

GNUNET_OK on success, else GNUNET_SYSERR

Definition at line 309 of file plugin_namecache_flat.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_HashCode query;
  struct FlatFileEntry *entry;
  size_t block_size;
 
  namecache_expire_blocks (plugin);
  GNUNET_GNSRECORD_query_from_block (block,
                                     &query);
  block_size = GNUNET_GNSRECORD_block_get_size (block);
  if (block_size > 64 * 65536)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  entry = GNUNET_malloc (sizeof(struct FlatFileEntry));
  entry->block = GNUNET_malloc (block_size);
  GNUNET_memcpy (entry->block, block, block_size);
  GNUNET_CONTAINER_multihashmap_remove_all (plugin->hm, &query);
  if (GNUNET_OK !=
      GNUNET_CONTAINER_multihashmap_put (plugin->hm,
                                         &query,
                                         entry,
                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
  {
    GNUNET_free (entry);
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Caching block under derived key `%s'\n",
              GNUNET_h2s_full (&query));
  return GNUNET_OK;
}

References FlatFileEntry::block, GNUNET_break, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_multihashmap_remove_all(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNSRECORD_block_get_size(), GNUNET_GNSRECORD_query_from_block(), GNUNET_h2s_full(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_OK, GNUNET_SYSERR, namecache_expire_blocks(), plugin, and FlatFileEntry::query.

Referenced by libgnunet_plugin_namecache_flat_init().

Here is the call graph for this function:

Here is the caller graph for this function:

namecache_lookup_block()

static int namecache_lookup_block ( void *  cls, const struct GNUNET_HashCode *  query, GNUNET_NAMECACHE_BlockCallback  iter, void *  iter_cls  )

static

Get the block for a particular zone and label in the datastore.

Will return at most one result to the iterator.

Parameters

cls	closure (internal context for the plugin)
query	hash of public key derived from the zone and the label
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 358 of file plugin_namecache_flat.c.

{
  struct Plugin *plugin = cls;
  const struct GNUNET_GNSRECORD_Block *block;
 
  block = GNUNET_CONTAINER_multihashmap_get (plugin->hm, query);
  if (NULL == block)
    return GNUNET_NO;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Found block under derived key `%s'\n",
              GNUNET_h2s_full (query));
  iter (iter_cls, block);
  return GNUNET_YES;
}

References GNUNET_CONTAINER_multihashmap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s_full(), GNUNET_log, GNUNET_NO, GNUNET_YES, and plugin.

Referenced by libgnunet_plugin_namecache_flat_init().

Here is the call graph for this function:

Here is the caller graph for this function:

libgnunet_plugin_namecache_flat_init()

void * libgnunet_plugin_namecache_flat_init

(

void *

cls

)

Entry point for the plugin.

Parameters

cls	the "struct GNUNET_NAMECACHE_PluginEnvironment*"

Returns

NULL on error, otherwise the plugin context

Definition at line 385 of file plugin_namecache_flat.c.

{
  static struct Plugin plugin;
  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
  struct GNUNET_NAMECACHE_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_NAMECACHE_PluginFunctions);
  api->cls = &plugin;
  api->cache_block = &namecache_cache_block;
  api->lookup_block = &namecache_lookup_block;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _ ("flat plugin running\n"));
  return api;
}

References _, GNUNET_NAMECACHE_PluginFunctions::cache_block, cfg, GNUNET_NAMECACHE_PluginFunctions::cls, database_setup(), database_shutdown(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_NAMECACHE_PluginFunctions::lookup_block, namecache_cache_block(), namecache_lookup_block(), and plugin.

Here is the call graph for this function:

libgnunet_plugin_namecache_flat_done()

void * libgnunet_plugin_namecache_flat_done

(

void *

cls

)

Exit point from the plugin.

Parameters

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

Returns

always NULL

Definition at line 419 of file plugin_namecache_flat.c.

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

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

Here is the call graph for this function: