plugin_peerstore_flat.c File Reference

flat file-based peerstore backend More...

#include "platform.h"
#include "gnunet_peerstore_plugin.h"
#include "gnunet_peerstore_service.h"
#include "peerstore.h"

Include dependency graph for plugin_peerstore_flat.c:

Go to the source code of this file.

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

Functions
static int	delete_entries (void *cls, const struct GNUNET_HashCode *key, void *value)
static int	peerstore_flat_delete_records (void *cls, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key)
	Delete records with the given key. More...
static int	expire_entries (void *cls, const struct GNUNET_HashCode *key, void *value)
static int	peerstore_flat_expire_records (void *cls, struct GNUNET_TIME_Absolute now, GNUNET_PEERSTORE_Continuation cont, void *cont_cls)
	Delete expired records (expiry < now) More...
static int	iterate_entries (void *cls, const struct GNUNET_HashCode *key, void *value)
static int	peerstore_flat_iterate_records (void *cls, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, GNUNET_PEERSTORE_Processor iter, void *iter_cls)
	Iterate over the records given an optional peer id and/or key. More...
static int	peerstore_flat_store_record (void *cls, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, const void *value, size_t size, struct GNUNET_TIME_Absolute expiry, enum GNUNET_PEERSTORE_StoreOption options, GNUNET_PEERSTORE_Continuation cont, void *cont_cls)
	Store a record in the peerstore. More...
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)
static void	database_shutdown (struct Plugin *plugin)
	Shutdown database connection and associate data structures. More...
void *	libgnunet_plugin_peerstore_flat_init (void *cls)
	Entry point for the plugin. More...
void *	libgnunet_plugin_peerstore_flat_done (void *cls)
	Exit point from the plugin. More...

Detailed Description

flat file-based peerstore backend

Author

Martin Schanzenbach

Definition in file plugin_peerstore_flat.c.

Function Documentation

delete_entries()

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

static

Definition at line 100 of file plugin_peerstore_flat.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_PEERSTORE_Record *entry = value;
 
  if (0 != strcmp (plugin->iter_key, entry->key))
    return GNUNET_YES;
  if (0 != memcmp (plugin->iter_peer,
                   &entry->peer,
                   sizeof(struct GNUNET_PeerIdentity)))
    return GNUNET_YES;
  if (0 != strcmp (plugin->iter_sub_system, entry->sub_system))
    return GNUNET_YES;
 
  GNUNET_CONTAINER_multihashmap_remove (plugin->hm, key, value);
  plugin->deleted_entries++;
  return GNUNET_YES;
}

References GNUNET_CONTAINER_multihashmap_remove(), GNUNET_YES, key, GNUNET_PEERSTORE_Record::key, GNUNET_PEERSTORE_Record::peer, plugin, GNUNET_PEERSTORE_Record::sub_system, and value.

Referenced by peerstore_flat_delete_records().

Here is the call graph for this function:

Here is the caller graph for this function:

peerstore_flat_delete_records()

static int peerstore_flat_delete_records ( void *  cls, const char *  sub_system, const struct GNUNET_PeerIdentity *  peer, const char *  key  )

static

Delete records with the given key.

Parameters

cls	closure (internal context for the plugin)
sub_system	name of sub system
peer	Peer identity (can be NULL)
key	entry key string (can be NULL)

Returns

number of deleted records

Definition at line 132 of file plugin_peerstore_flat.c.

{
  struct Plugin *plugin = cls;
 
  plugin->iter_sub_system = sub_system;
  plugin->iter_peer = peer;
  plugin->iter_key = key;
  plugin->deleted_entries = 0;
 
  GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
                                         &delete_entries,
                                         plugin);
  return plugin->deleted_entries;
}

References delete_entries(), GNUNET_CONTAINER_multihashmap_iterate(), key, peer, and plugin.

Referenced by peerstore_flat_store_record().

Here is the call graph for this function:

Here is the caller graph for this function:

expire_entries()

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

static

Definition at line 151 of file plugin_peerstore_flat.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_PEERSTORE_Record *entry = value;
 
  if (entry->expiry.abs_value_us < plugin->iter_now.abs_value_us)
  {
    GNUNET_CONTAINER_multihashmap_remove (plugin->hm, key, value);
    plugin->exp_changes++;
  }
  return GNUNET_YES;
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_PEERSTORE_Record::expiry, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_YES, key, plugin, and value.

Referenced by peerstore_flat_expire_records().

Here is the call graph for this function:

Here is the caller graph for this function:

peerstore_flat_expire_records()

static int peerstore_flat_expire_records ( void *  cls, struct GNUNET_TIME_Absolute  now, GNUNET_PEERSTORE_Continuation  cont, void *  cont_cls  )

static

Delete expired records (expiry < now)

Parameters

cls	closure (internal context for the plugin)
now	time to use as reference
cont	continuation called with the number of records expired
cont_cls	continuation closure

Returns

GNUNET_OK on success, GNUNET_SYSERR on error and cont is not called

Definition at line 178 of file plugin_peerstore_flat.c.

{
  struct Plugin *plugin = cls;
 
  plugin->exp_changes = 0;
  plugin->iter_now = now;
 
  GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
                                         &expire_entries,
                                         plugin);
  if (NULL != cont)
  {
    cont (cont_cls, plugin->exp_changes);
  }
  return GNUNET_OK;
}

References expire_entries(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_OK, and plugin.

Referenced by libgnunet_plugin_peerstore_flat_init().

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_entries()

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

static

Definition at line 199 of file plugin_peerstore_flat.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_PEERSTORE_Record *entry = value;
 
  if ((NULL != plugin->iter_peer) &&
      (0 != memcmp (plugin->iter_peer,
                    &entry->peer,
                    sizeof(struct GNUNET_PeerIdentity))))
  {
    return GNUNET_YES;
  }
  if ((NULL != plugin->iter_key) &&
      (0 != strcmp (plugin->iter_key,
                    entry->key)))
  {
    return GNUNET_YES;
  }
  if (NULL != plugin->iter)
    plugin->iter (plugin->iter_cls, entry, NULL);
  plugin->iter_result_found = GNUNET_YES;
  return GNUNET_YES;
}

References GNUNET_YES, GNUNET_PEERSTORE_Record::key, GNUNET_PEERSTORE_Record::peer, plugin, and value.

Referenced by peerstore_flat_iterate_records().

Here is the caller graph for this function:

peerstore_flat_iterate_records()

static int peerstore_flat_iterate_records ( void *  cls, const char *  sub_system, const struct GNUNET_PeerIdentity *  peer, const char *  key, GNUNET_PEERSTORE_Processor  iter, void *  iter_cls  )

static

Iterate over the records given an optional peer id and/or key.

Parameters

cls	closure (internal context for the plugin)
sub_system	name of sub system
peer	Peer identity (can be NULL)
key	entry key string (can be NULL)
iter	function to call asynchronously with the results, terminated by a NULL result
iter_cls	closure for iter

Returns

GNUNET_OK on success, GNUNET_SYSERR on error and iter is not called

Definition at line 241 of file plugin_peerstore_flat.c.

{
  struct Plugin *plugin = cls;
 
  plugin->iter = iter;
  plugin->iter_cls = iter_cls;
  plugin->iter_peer = peer;
  plugin->iter_sub_system = sub_system;
  plugin->iter_key = key;
 
  GNUNET_CONTAINER_multihashmap_iterate (plugin->hm,
                                         &iterate_entries,
                                         plugin);
  if (NULL != iter)
    iter (iter_cls, NULL, NULL);
  return GNUNET_OK;
}

References GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_OK, Plugin::iter, Plugin::iter_cls, iterate_entries(), key, peer, and plugin.

Referenced by libgnunet_plugin_peerstore_flat_init().

Here is the call graph for this function:

Here is the caller graph for this function:

peerstore_flat_store_record()

static int peerstore_flat_store_record ( void *  cls, const char *  sub_system, const struct GNUNET_PeerIdentity *  peer, const char *  key, const void *  value, size_t  size, struct GNUNET_TIME_Absolute  expiry, enum GNUNET_PEERSTORE_StoreOption  options, GNUNET_PEERSTORE_Continuation  cont, void *  cont_cls  )

static

Store a record in the peerstore.

Key is the combination of sub system and peer identity. One key can store multiple values.

Parameters

cls	closure (internal context for the plugin)
sub_system	name of the GNUnet sub system responsible
peer	peer identity
key	record key string
value	value to be stored
size	size of value to be stored
expiry	absolute time after which the record is (possibly) deleted
options	options related to the store operation
cont	continuation called when record is stored
cont_cls	continuation closure

Returns

GNUNET_OK on success, else GNUNET_SYSERR and cont is not called

Definition at line 282 of file plugin_peerstore_flat.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_HashCode hkey;
  struct GNUNET_PEERSTORE_Record *entry;
  const char *peer_id;
 
 
  entry = GNUNET_new (struct GNUNET_PEERSTORE_Record);
  entry->sub_system = GNUNET_strdup (sub_system);
  entry->key = GNUNET_strdup (key);
  entry->value = GNUNET_malloc (size);
  GNUNET_memcpy (entry->value, value, size);
  entry->value_size = size;
  entry->peer = *peer;
  entry->expiry = expiry;
 
  peer_id = GNUNET_i2s (peer);
  GNUNET_CRYPTO_hash (peer_id,
                      strlen (peer_id),
                      &hkey);
 
  if (GNUNET_PEERSTORE_STOREOPTION_REPLACE == options)
  {
    peerstore_flat_delete_records (cls, sub_system, peer, key);
  }
 
  GNUNET_CONTAINER_multihashmap_put (plugin->hm,
                                     &hkey,
                                     entry,
                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  if (NULL != cont)
  {
    cont (cont_cls, GNUNET_OK);
  }
  return GNUNET_OK;
}

References GNUNET_PEERSTORE_Record::expiry, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CRYPTO_hash(), GNUNET_i2s(), GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_OK, GNUNET_PEERSTORE_STOREOPTION_REPLACE, GNUNET_strdup, key, GNUNET_PEERSTORE_Record::key, options, GNUNET_PEERSTORE_Record::peer, peer, peer_id, peerstore_flat_delete_records(), plugin, size, GNUNET_PEERSTORE_Record::sub_system, GNUNET_PEERSTORE_Record::value, value, and GNUNET_PEERSTORE_Record::value_size.

Referenced by libgnunet_plugin_peerstore_flat_init().

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 336 of file plugin_peerstore_flat.c.

{
  char *afsdir;
  char *key;
  char *sub_system;
  const char *peer_id;
  char *peer;
  char *value;
  char *expiry;
  struct GNUNET_DISK_FileHandle *fh;
  struct GNUNET_PEERSTORE_Record *entry;
  struct GNUNET_HashCode hkey;
  uint64_t size;
  char *buffer;
  char *line;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (plugin->cfg, "peerstore-flat",
                                               "FILENAME", &afsdir))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "peerstore-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;
 
  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;
  }
 
  /* Load data from file into hashmap */
  plugin->hm = GNUNET_CONTAINER_multihashmap_create (10,
                                                     GNUNET_NO);
 
  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);
    return GNUNET_SYSERR;
  }
 
  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_DISK_file_close (fh);
    GNUNET_free (buffer);
    return GNUNET_SYSERR;
  }
 
  buffer[size] = '\0';
  GNUNET_DISK_file_close (fh);
  if (0 < size)
  {
    line = strtok (buffer, "\n");
    while (line != NULL)
    {
      sub_system = strtok (line, ",");
      if (NULL == sub_system)
        break;
      peer = strtok (NULL, ",");
      if (NULL == peer)
        break;
      key = strtok (NULL, ",");
      if (NULL == key)
        break;
      value = strtok (NULL, ",");
      if (NULL == value)
        break;
      expiry = strtok (NULL, ",");
      if (NULL == expiry)
        break;
      entry = GNUNET_new (struct GNUNET_PEERSTORE_Record);
      entry->sub_system = GNUNET_strdup (sub_system);
      entry->key = GNUNET_strdup (key);
      {
        size_t s;
        char *o;
 
        o = NULL;
        s = GNUNET_STRINGS_base64_decode (peer,
                                          strlen (peer),
                                          (void **) &o);
        if (sizeof(struct GNUNET_PeerIdentity) == s)
          GNUNET_memcpy (&entry->peer,
                         o,
                         s);
        else
          GNUNET_break (0);
        GNUNET_free (o);
      }
      entry->value_size = GNUNET_STRINGS_base64_decode (value,
                                                        strlen (value),
                                                        (void **) &entry->value);
      if (GNUNET_SYSERR ==
          GNUNET_STRINGS_fancy_time_to_absolute (expiry,
                                                 &entry->expiry))
      {
        GNUNET_free (entry->sub_system);
        GNUNET_free (entry->key);
        GNUNET_free (entry);
        break;
      }
      peer_id = GNUNET_i2s (&entry->peer);
      GNUNET_CRYPTO_hash (peer_id,
                          strlen (peer_id),
                          &hkey);
 
      GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (plugin->hm,
                                                                     &hkey,
                                                                     entry,
                                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
    }
  }
  GNUNET_free (buffer);
  return GNUNET_OK;
}

References _, GNUNET_PEERSTORE_Record::expiry, fh, GNUNET_assert, GNUNET_break, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CRYPTO_hash(), 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_i2s(), GNUNET_log, GNUNET_log_config_missing(), GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_strdup, GNUNET_STRINGS_base64_decode(), GNUNET_STRINGS_fancy_time_to_absolute(), GNUNET_SYSERR, GNUNET_YES, key, GNUNET_PEERSTORE_Record::key, line, GNUNET_PEERSTORE_Record::peer, peer, peer_id, plugin, size, GNUNET_PEERSTORE_Record::sub_system, GNUNET_PEERSTORE_Record::value, value, and GNUNET_PEERSTORE_Record::value_size.

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

Definition at line 484 of file plugin_peerstore_flat.c.

{
  struct GNUNET_DISK_FileHandle *fh = cls;
  struct GNUNET_PEERSTORE_Record *entry = value;
  char *line;
  char *peer;
  const char *expiry;
  char *val;
 
  GNUNET_STRINGS_base64_encode (entry->value,
                                entry->value_size,
                                &val);
  expiry = GNUNET_STRINGS_absolute_time_to_string (entry->expiry);
  GNUNET_STRINGS_base64_encode ((char *) &entry->peer,
                                sizeof(struct GNUNET_PeerIdentity),
                                &peer);
  GNUNET_asprintf (&line,
                   "%s,%s,%s,%s,%s",
                   entry->sub_system,
                   peer,
                   entry->key,
                   val,
                   expiry);
  GNUNET_free (val);
  GNUNET_free (peer);
  GNUNET_DISK_file_write (fh,
                          line,
                          strlen (line));
  GNUNET_free (entry->sub_system);
  GNUNET_free (entry->key);
  GNUNET_free (entry->value);
  GNUNET_free (entry);
  GNUNET_free (line);
  return GNUNET_YES;
}

References GNUNET_PEERSTORE_Record::expiry, fh, GNUNET_asprintf(), GNUNET_DISK_file_write(), GNUNET_free, GNUNET_STRINGS_absolute_time_to_string(), GNUNET_STRINGS_base64_encode(), GNUNET_YES, GNUNET_PEERSTORE_Record::key, line, GNUNET_PEERSTORE_Record::peer, peer, GNUNET_PEERSTORE_Record::sub_system, GNUNET_PEERSTORE_Record::value, value, and GNUNET_PEERSTORE_Record::value_size.

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 529 of file plugin_peerstore_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 _, fh, 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_peerstore_flat_done(), and libgnunet_plugin_peerstore_flat_init().

Here is the call graph for this function:

Here is the caller graph for this function:

libgnunet_plugin_peerstore_flat_init()

void* libgnunet_plugin_peerstore_flat_init

(

void *

cls

)

Entry point for the plugin.

Parameters

cls	The struct GNUNET_CONFIGURATION_Handle.

Returns

NULL on error, otherwise the plugin context

Definition at line 561 of file plugin_peerstore_flat.c.

{
  static struct Plugin plugin;
  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
  struct GNUNET_PEERSTORE_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_PEERSTORE_PluginFunctions);
  api->cls = &plugin;
  api->store_record = &peerstore_flat_store_record;
  api->iterate_records = &peerstore_flat_iterate_records;
  api->expire_records = &peerstore_flat_expire_records;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Flat plugin is running\n");
  return api;
}

References cfg, GNUNET_PEERSTORE_PluginFunctions::cls, database_setup(), database_shutdown(), GNUNET_PEERSTORE_PluginFunctions::expire_records, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_PEERSTORE_PluginFunctions::iterate_records, peerstore_flat_expire_records(), peerstore_flat_iterate_records(), peerstore_flat_store_record(), plugin, and GNUNET_PEERSTORE_PluginFunctions::store_record.

Here is the call graph for this function:

libgnunet_plugin_peerstore_flat_done()

void* libgnunet_plugin_peerstore_flat_done

(

void *

cls

)

Exit point from the plugin.

Parameters

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

Returns

Always NULL

Definition at line 593 of file plugin_peerstore_flat.c.

{
  struct GNUNET_PEERSTORE_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_PEERSTORE_PluginFunctions::cls, database_shutdown(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, and plugin.

Here is the call graph for this function: