Data Cache library

Simple, transient hash table of bounded size with content expiration. More...

Typedefs
typedef int(*	GNUNET_DATACACHE_Iterator) (void *cls, const struct GNUNET_HashCode *key, size_t data_size, const char *data, enum GNUNET_BLOCK_Type type, struct GNUNET_TIME_Absolute exp, unsigned int path_info_len, const struct GNUNET_PeerIdentity *path_info)
	An iterator over a set of items stored in the datacache. More...

Functions
struct GNUNET_DATACACHE_Handle *	GNUNET_DATACACHE_create (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section)
	Create a data cache. More...
void	GNUNET_DATACACHE_destroy (struct GNUNET_DATACACHE_Handle *h)
	Destroy a data cache (and free associated resources). More...
int	GNUNET_DATACACHE_put (struct GNUNET_DATACACHE_Handle *h, const struct GNUNET_HashCode *key, uint32_t xor_distance, size_t data_size, const char *data, enum GNUNET_BLOCK_Type type, struct GNUNET_TIME_Absolute discard_time, unsigned int path_info_len, const struct GNUNET_PeerIdentity *path_info)
	Store an item in the datacache. More...
unsigned int	GNUNET_DATACACHE_get (struct GNUNET_DATACACHE_Handle *h, const struct GNUNET_HashCode *key, enum GNUNET_BLOCK_Type type, GNUNET_DATACACHE_Iterator iter, void *iter_cls)
	Iterate over the results for a particular key in the datacache. More...
unsigned int	GNUNET_DATACACHE_get_random (struct GNUNET_DATACACHE_Handle *h, GNUNET_DATACACHE_Iterator iter, void *iter_cls)
	Obtain a random element from the datacache. More...
unsigned int	GNUNET_DATACACHE_get_closest (struct GNUNET_DATACACHE_Handle *h, const struct GNUNET_HashCode *key, unsigned int num_results, GNUNET_DATACACHE_Iterator iter, void *iter_cls)
	Iterate over the results that are "close" to a particular key in the datacache. More...

Detailed Description

Simple, transient hash table of bounded size with content expiration.

In contrast to the sqstore there is no prioritization, deletion or iteration. All of the data is discarded when the peer shuts down!

Typedef Documentation

GNUNET_DATACACHE_Iterator

typedef int(* GNUNET_DATACACHE_Iterator) (void *cls, const struct GNUNET_HashCode *key, size_t data_size, const char *data, enum GNUNET_BLOCK_Type type, struct GNUNET_TIME_Absolute exp, unsigned int path_info_len, const struct GNUNET_PeerIdentity *path_info)

An iterator over a set of items stored in the datacache.

Parameters

cls	closure
key	key for the content
data_size	number of bytes in data
data	content stored
type	type of the content
exp	when will the content expire?
path_info_len	number of entries in path_info
path_info	a path through the network

Returns

GNUNET_OK to continue iterating, GNUNET_SYSERR to abort

Definition at line 93 of file gnunet_datacache_lib.h.

Function Documentation

GNUNET_DATACACHE_create()

struct GNUNET_DATACACHE_Handle* GNUNET_DATACACHE_create	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section
	)

Create a data cache.

Parameters

cfg	configuration to use
section	section in the configuration that contains our options

Returns

handle to use to access the service

Definition at line 132 of file datacache.c.

References _, GNUNET_DATACACHE_Handle::api, GNUNET_DATACACHE_Handle::bloom_name, GNUNET_DATACACHE_Handle::cfg, GNUNET_DATACACHE_PluginEnvironment::cfg, GNUNET_DATACACHE_PluginEnvironment::cls, GNUNET_DATACACHE_PluginEnvironment::delete_notify, GNUNET_DATACACHE_Handle::env, env_delete_notify(), GNUNET_DATACACHE_Handle::filter, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_size(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONTAINER_bloomfilter_init(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_DATACACHE_destroy(), GNUNET_DISK_mktemp(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log_config_missing(), GNUNET_new, GNUNET_OK, GNUNET_PLUGIN_load(), GNUNET_STATISTICS_create(), GNUNET_strdup, GNUNET_YES, GNUNET_DATACACHE_Handle::lib_name, LOG, name, GNUNET_DATACACHE_PluginEnvironment::quota, quota, ret, GNUNET_DATACACHE_Handle::section, GNUNET_DATACACHE_PluginEnvironment::section, GNUNET_DATACACHE_Handle::short_name, and GNUNET_DATACACHE_Handle::stats.

Referenced by GDS_DATACACHE_init().

{
  unsigned int bf_size;
  unsigned long long quota;
  struct GNUNET_DATACACHE_Handle *ret;
  char *libname;
  char *name;

  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_size(cfg, section, "QUOTA", &quota))
    {
      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, section, "QUOTA");
      return NULL;
    }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string(cfg, section, "DATABASE", &name))
    {
      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, section, "DATABASE");
      return NULL;
    }
  bf_size = quota / 32; /* 8 bit per entry, 1 bit per 32 kb in DB */

  ret = GNUNET_new(struct GNUNET_DATACACHE_Handle);

  if (GNUNET_YES !=
      GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "DISABLE_BF"))
    {
      if (GNUNET_YES !=
          GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "DISABLE_BF_RC"))
        {
          ret->bloom_name = GNUNET_DISK_mktemp("gnunet-datacachebloom");
        }
      if (NULL != ret->bloom_name)
        {
          ret->filter = GNUNET_CONTAINER_bloomfilter_load(
            ret->bloom_name,
            quota / 1024, /* 8 bit per entry in DB, expect 1k entries */
            5);
        }
      if (NULL == ret->filter)
        {
          ret->filter =
            GNUNET_CONTAINER_bloomfilter_init(NULL,
                                              bf_size,
                                              5); /* approx. 3% false positives at max use */
        }
    }
  ret->stats = GNUNET_STATISTICS_create("datacache", cfg);
  ret->section = GNUNET_strdup(section);
  ret->env.cfg = cfg;
  ret->env.delete_notify = &env_delete_notify;
  ret->env.section = ret->section;
  ret->env.cls = ret;
  ret->env.delete_notify = &env_delete_notify;
  ret->env.quota = quota;
  LOG(GNUNET_ERROR_TYPE_INFO, _("Loading `%s' datacache plugin\n"), name);
  GNUNET_asprintf(&libname, "libgnunet_plugin_datacache_%s", name);
  ret->short_name = name;
  ret->lib_name = libname;
  ret->api = GNUNET_PLUGIN_load(libname, &ret->env);
  if (ret->api == NULL)
    {
      LOG(GNUNET_ERROR_TYPE_ERROR,
          _("Failed to load datacache plugin for `%s'\n"),
          name);
      GNUNET_DATACACHE_destroy(ret);
      return NULL;
    }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DATACACHE_destroy()

void GNUNET_DATACACHE_destroy

(

struct GNUNET_DATACACHE_Handle *

h

)

Destroy a data cache (and free associated resources).

Parameters

h	handle to the datastore

Definition at line 211 of file datacache.c.

References GNUNET_DATACACHE_Handle::api, GNUNET_DATACACHE_Handle::bloom_name, GNUNET_DATACACHE_Handle::filter, GNUNET_break, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_from_strerror_file, GNUNET_NO, GNUNET_PLUGIN_unload(), GNUNET_STATISTICS_destroy(), GNUNET_DATACACHE_Handle::lib_name, GNUNET_DATACACHE_Handle::section, GNUNET_DATACACHE_Handle::short_name, and GNUNET_DATACACHE_Handle::stats.

Referenced by GDS_DATACACHE_done(), and GNUNET_DATACACHE_create().

{
  if (NULL != h->filter)
    GNUNET_CONTAINER_bloomfilter_free(h->filter);
  if (NULL != h->api)
    GNUNET_break(NULL == GNUNET_PLUGIN_unload(h->lib_name, h->api));
  GNUNET_free(h->lib_name);
  GNUNET_free(h->short_name);
  GNUNET_free(h->section);
  if (NULL != h->bloom_name)
    {
      if (0 != unlink(h->bloom_name))
        GNUNET_log_from_strerror_file(GNUNET_ERROR_TYPE_WARNING,
                                      "datacache",
                                      "unlink",
                                      h->bloom_name);
      GNUNET_free(h->bloom_name);
    }
  GNUNET_STATISTICS_destroy(h->stats, GNUNET_NO);
  GNUNET_free(h);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DATACACHE_put()

int GNUNET_DATACACHE_put	(	struct GNUNET_DATACACHE_Handle *	h,
		const struct GNUNET_HashCode *	key,
		uint32_t	xor_distance,
		size_t	data_size,
		const char *	data,
		enum GNUNET_BLOCK_Type	type,
		struct GNUNET_TIME_Absolute	discard_time,
		unsigned int	path_info_len,
		const struct GNUNET_PeerIdentity *	path_info
	)

Store an item in the datacache.

Parameters

h	handle to the datacache
key	key to store data under
how	close is key to our pid?
data_size	number of bytes in data
data	data to store
type	type of the value
discard_time	when to discard the value in any case
path_info_len	number of entries in path_info
path_info	a path through the network

Returns

GNUNET_OK on success, GNUNET_SYSERR on error, GNUNET_NO if duplicate

Store an item in the datacache.

Parameters

h	handle to the datacache
key	key to store data under
xor_distance	distance of key to our PID
data_size	number of bytes in data
data	data to store
type	type of the value
discard_time	when to discard the value in any case
path_info_len	number of entries in path_info
path_info	a path through the network

Returns

GNUNET_OK on success, GNUNET_SYSERR on error, GNUNET_NO if duplicate

Definition at line 249 of file datacache.c.

References GNUNET_DATACACHE_Handle::api, GNUNET_DATACACHE_PluginFunctions::cls, GNUNET_DATACACHE_PluginFunctions::del, GNUNET_DATACACHE_Handle::env, GNUNET_DATACACHE_Handle::filter, gettext_noop, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_bloomfilter_add(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, LOG, GNUNET_DATACACHE_PluginFunctions::put, GNUNET_DATACACHE_PluginEnvironment::quota, GNUNET_DATACACHE_Handle::stats, and GNUNET_DATACACHE_Handle::utilization.

Referenced by GDS_DATACACHE_handle_put().

{
  ssize_t used;

  used = h->api->put(h->api->cls,
                     key,
                     xor_distance,
                     data_size,
                     data,
                     type,
                     discard_time,
                     path_info_len,
                     path_info);
  if (-1 == used)
    {
      GNUNET_break(0);
      return GNUNET_SYSERR;
    }
  if (0 == used)
    {
      /* duplicate */
      return GNUNET_NO;
    }
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Stored data under key `%s' in cache\n",
      GNUNET_h2s(key));
  if (NULL != h->filter)
    GNUNET_CONTAINER_bloomfilter_add(h->filter, key);
  GNUNET_STATISTICS_update(h->stats,
                           gettext_noop("# bytes stored"),
                           used,
                           GNUNET_NO);
  GNUNET_STATISTICS_update(h->stats,
                           gettext_noop("# items stored"),
                           1,
                           GNUNET_NO);
  while (h->utilization + used > h->env.quota)
    GNUNET_assert(GNUNET_OK == h->api->del(h->api->cls));
  h->utilization += used;
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DATACACHE_get()

unsigned int GNUNET_DATACACHE_get	(	struct GNUNET_DATACACHE_Handle *	h,
		const struct GNUNET_HashCode *	key,
		enum GNUNET_BLOCK_Type	type,
		GNUNET_DATACACHE_Iterator	iter,
		void *	iter_cls
	)

Iterate over the results for a particular key in the datacache.

Parameters

h	handle to the datacache
key	what to look up
type	entries of which type are relevant?
iter	maybe NULL (to just count)
iter_cls	closure for iter

Returns

the number of results found

Definition at line 312 of file datacache.c.

References GNUNET_DATACACHE_Handle::api, GNUNET_DATACACHE_PluginFunctions::cls, GNUNET_DATACACHE_Handle::filter, GNUNET_DATACACHE_PluginFunctions::get, gettext_noop, GNUNET_CONTAINER_bloomfilter_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), LOG, and GNUNET_DATACACHE_Handle::stats.

Referenced by GDS_DATACACHE_handle_get().

{
  GNUNET_STATISTICS_update(h->stats,
                           gettext_noop("# requests received"),
                           1,
                           GNUNET_NO);
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Processing request for key `%s'\n",
      GNUNET_h2s(key));
  if ((NULL != h->filter) &&
      (GNUNET_OK != GNUNET_CONTAINER_bloomfilter_test(h->filter, key)))
    {
      GNUNET_STATISTICS_update(h->stats,
                               gettext_noop(
                                 "# requests filtered by bloom filter"),
                               1,
                               GNUNET_NO);
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Bloomfilter filters request for key `%s'\n",
          GNUNET_h2s(key));
      return 0; /* can not be present */
    }
  return h->api->get(h->api->cls, key, type, iter, iter_cls);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DATACACHE_get_random()

unsigned int GNUNET_DATACACHE_get_random	(	struct GNUNET_DATACACHE_Handle *	h,
		GNUNET_DATACACHE_Iterator	iter,
		void *	iter_cls
	)

Obtain a random element from the datacache.

Parameters

h	handle to the datacache
iter	maybe NULL (to just count)
iter_cls	closure for iter

Returns

the number of results found (zero or 1)

Definition at line 351 of file datacache.c.

References GNUNET_DATACACHE_Handle::api, GNUNET_DATACACHE_PluginFunctions::cls, GNUNET_DATACACHE_PluginFunctions::get_random, gettext_noop, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_STATISTICS_update(), LOG, and GNUNET_DATACACHE_Handle::stats.

Referenced by GDS_DATACACHE_get_random_key().

{
  GNUNET_STATISTICS_update(h->stats,
                           gettext_noop(
                             "# requests for random value received"),
                           1,
                           GNUNET_NO);
  LOG(GNUNET_ERROR_TYPE_DEBUG, "Processing request for random value\n");
  return h->api->get_random(h->api->cls, iter, iter_cls);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DATACACHE_get_closest()

unsigned int GNUNET_DATACACHE_get_closest	(	struct GNUNET_DATACACHE_Handle *	h,
		const struct GNUNET_HashCode *	key,
		unsigned int	num_results,
		GNUNET_DATACACHE_Iterator	iter,
		void *	iter_cls
	)

Iterate over the results that are "close" to a particular key in the datacache.

"close" is defined as numerically larger than key (when interpreted as a circular address space), with small distance.

Parameters

h	handle to the datacache
key	area of the keyspace to look into
num_results	number of results that should be returned to iter
iter	maybe NULL (to just count)
iter_cls	closure for iter

Returns

the number of results found

Definition at line 379 of file datacache.c.

References GNUNET_DATACACHE_Handle::api, GNUNET_DATACACHE_PluginFunctions::cls, GNUNET_DATACACHE_PluginFunctions::get_closest, gettext_noop, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_NO, GNUNET_STATISTICS_update(), LOG, and GNUNET_DATACACHE_Handle::stats.

Referenced by GDS_DATACACHE_get_successors().

{
  GNUNET_STATISTICS_update(h->stats,
                           gettext_noop(
                             "# proximity search requests received"),
                           1,
                           GNUNET_NO);
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Processing proximity search at `%s'\n",
      GNUNET_h2s(key));
  return h->api->get_closest(h->api->cls, key, num_results, iter, iter_cls);
}

Here is the call graph for this function:

Here is the caller graph for this function: