plugin_namecache_postgres.c File Reference

postgres-based namecache backend More...

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

Include dependency graph for plugin_namecache_postgres.c:

Go to the source code of this file.

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

Macros
#define	LOG(kind, ...)   GNUNET_log_from(kind, "namecache-postgres", __VA_ARGS__)

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 void	namecache_postgres_expire_blocks (struct Plugin *plugin)
	Removes any expired block. More...
static void	delete_old_block (struct Plugin *plugin, const struct GNUNET_HashCode *query, struct GNUNET_TIME_AbsoluteNBO expiration_time)
	Delete older block in the datastore. More...
static int	namecache_postgres_cache_block (void *cls, const struct GNUNET_GNSRECORD_Block *block)
	Cache a block in the datastore. More...
static int	namecache_postgres_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...
static void	database_shutdown (struct Plugin *plugin)
	Shutdown database connection and associate data structures. More...
void *	libgnunet_plugin_namecache_postgres_init (void *cls)
	Entry point for the plugin. More...
void *	libgnunet_plugin_namecache_postgres_done (void *cls)
	Exit point from the plugin. More...

Detailed Description

postgres-based namecache backend

Author

Christian Grothoff

Definition in file plugin_namecache_postgres.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from(kind, "namecache-postgres", __VA_ARGS__)

Definition at line 34 of file plugin_namecache_postgres.c.

Referenced by libgnunet_plugin_namecache_postgres_done(), libgnunet_plugin_namecache_postgres_init(), and namecache_postgres_lookup_block().

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 59 of file plugin_namecache_postgres.c.

References Plugin::cfg, Plugin::dbh, GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_OK, GNUNET_PQ_connect_with_cfg(), GNUNET_PQ_exec_statements(), GNUNET_PQ_EXECUTE_STATEMENT_END, GNUNET_PQ_make_execute(), GNUNET_PQ_make_prepare(), GNUNET_PQ_make_try_execute(), GNUNET_PQ_prepare_statements(), GNUNET_PQ_PREPARED_STATEMENT_END, GNUNET_SYSERR, and GNUNET_YES.

Referenced by libgnunet_plugin_namecache_postgres_init().

{
  struct GNUNET_PQ_ExecuteStatement es_temporary =
    GNUNET_PQ_make_execute("CREATE TEMPORARY TABLE IF NOT EXISTS ns096blocks ("
                           " query BYTEA NOT NULL DEFAULT '',"
                           " block BYTEA NOT NULL DEFAULT '',"
                           " expiration_time BIGINT NOT NULL DEFAULT 0"
                           ")"
                           "WITH OIDS");
  struct GNUNET_PQ_ExecuteStatement es_default =
    GNUNET_PQ_make_execute("CREATE TABLE IF NOT EXISTS ns096blocks ("
                           " query BYTEA NOT NULL DEFAULT '',"
                           " block BYTEA NOT NULL DEFAULT '',"
                           " expiration_time BIGINT NOT NULL DEFAULT 0"
                           ")"
                           "WITH OIDS");
  const struct GNUNET_PQ_ExecuteStatement *cr;

  plugin->dbh = GNUNET_PQ_connect_with_cfg(plugin->cfg,
                                           "namecache-postgres");
  if (NULL == plugin->dbh)
    return GNUNET_SYSERR;
  if (GNUNET_YES ==
      GNUNET_CONFIGURATION_get_value_yesno(plugin->cfg,
                                           "namecache-postgres",
                                           "TEMPORARY_TABLE"))
    {
      cr = &es_temporary;
    }
  else
    {
      cr = &es_default;
    }

  {
    struct GNUNET_PQ_ExecuteStatement es[] = {
      *cr,
      GNUNET_PQ_make_try_execute("CREATE INDEX ir_query_hash ON ns096blocks (query,expiration_time)"),
      GNUNET_PQ_make_try_execute("CREATE INDEX ir_block_expiration ON ns096blocks (expiration_time)"),
      GNUNET_PQ_EXECUTE_STATEMENT_END
    };

    if (GNUNET_OK !=
        GNUNET_PQ_exec_statements(plugin->dbh,
                                  es))
      {
        PQfinish(plugin->dbh);
        plugin->dbh = NULL;
        return GNUNET_SYSERR;
      }
  }

  {
    struct GNUNET_PQ_PreparedStatement ps[] = {
      GNUNET_PQ_make_prepare("cache_block",
                             "INSERT INTO ns096blocks (query, block, expiration_time) VALUES "
                             "($1, $2, $3)", 3),
      GNUNET_PQ_make_prepare("expire_blocks",
                             "DELETE FROM ns096blocks WHERE expiration_time<$1", 1),
      GNUNET_PQ_make_prepare("delete_block",
                             "DELETE FROM ns096blocks WHERE query=$1 AND expiration_time<=$2", 2),
      GNUNET_PQ_make_prepare("lookup_block",
                             "SELECT block FROM ns096blocks WHERE query=$1"
                             " ORDER BY expiration_time DESC LIMIT 1", 1),
      GNUNET_PQ_PREPARED_STATEMENT_END
    };

    if (GNUNET_OK !=
        GNUNET_PQ_prepare_statements(plugin->dbh,
                                     ps))
      {
        PQfinish(plugin->dbh);
        plugin->dbh = NULL;
        return GNUNET_SYSERR;
      }
  }

  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

namecache_postgres_expire_blocks()

static void namecache_postgres_expire_blocks ( struct Plugin *  plugin )

static

Removes any expired block.

Parameters

plugin

the plugin

Definition at line 146 of file plugin_namecache_postgres.c.

References Plugin::dbh, GNUNET_break, GNUNET_DB_STATUS_HARD_ERROR, GNUNET_PQ_eval_prepared_non_select(), GNUNET_PQ_query_param_absolute_time(), GNUNET_PQ_query_param_end, GNUNET_TIME_absolute_get(), and res.

Referenced by namecache_postgres_cache_block().

{
  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get();
  struct GNUNET_PQ_QueryParam params[] = {
    GNUNET_PQ_query_param_absolute_time(&now),
    GNUNET_PQ_query_param_end
  };
  enum GNUNET_DB_QueryStatus res;

  res = GNUNET_PQ_eval_prepared_non_select(plugin->dbh,
                                           "expire_blocks",
                                           params);
  GNUNET_break(GNUNET_DB_STATUS_HARD_ERROR != res);
}

Here is the call graph for this function:

Here is the caller graph for this function:

delete_old_block()

static void delete_old_block ( struct Plugin *  plugin, const struct GNUNET_HashCode *  query, struct GNUNET_TIME_AbsoluteNBO  expiration_time  )

static

Delete older block in the datastore.

Parameters

plugin	the plugin
query	query for the block
expiration_time	how old does the block have to be for deletion

Definition at line 170 of file plugin_namecache_postgres.c.

References Plugin::dbh, GNUNET_break, GNUNET_DB_STATUS_HARD_ERROR, GNUNET_PQ_eval_prepared_non_select(), GNUNET_PQ_query_param_absolute_time_nbo(), GNUNET_PQ_query_param_auto_from_type, GNUNET_PQ_query_param_end, and res.

Referenced by namecache_postgres_cache_block().

{
  struct GNUNET_PQ_QueryParam params[] = {
    GNUNET_PQ_query_param_auto_from_type(query),
    GNUNET_PQ_query_param_absolute_time_nbo(&expiration_time),
    GNUNET_PQ_query_param_end
  };
  enum GNUNET_DB_QueryStatus res;

  res = GNUNET_PQ_eval_prepared_non_select(plugin->dbh,
                                           "delete_block",
                                           params);
  GNUNET_break(GNUNET_DB_STATUS_HARD_ERROR != res);
}

Here is the call graph for this function:

Here is the caller graph for this function:

namecache_postgres_cache_block()

static int namecache_postgres_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 196 of file plugin_namecache_postgres.c.

References Plugin::dbh, delete_old_block(), GNUNET_GNSRECORD_Block::derived_key, GNUNET_GNSRECORD_Block::expiration_time, GNUNET_break, GNUNET_CRYPTO_hash(), GNUNET_OK, GNUNET_PQ_eval_prepared_non_select(), GNUNET_PQ_query_param_absolute_time_nbo(), GNUNET_PQ_query_param_auto_from_type, GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_fixed_size(), GNUNET_SYSERR, namecache_postgres_expire_blocks(), plugin, GNUNET_GNSRECORD_Block::purpose, res, and GNUNET_CRYPTO_EccSignaturePurpose::size.

Referenced by libgnunet_plugin_namecache_postgres_init().

{
  struct Plugin *plugin = cls;
  struct GNUNET_HashCode query;
  size_t block_size = ntohl(block->purpose.size) +
                      sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey) +
                      sizeof(struct GNUNET_CRYPTO_EcdsaSignature);
  struct GNUNET_PQ_QueryParam params[] = {
    GNUNET_PQ_query_param_auto_from_type(&query),
    GNUNET_PQ_query_param_fixed_size(block, block_size),
    GNUNET_PQ_query_param_absolute_time_nbo(&block->expiration_time),
    GNUNET_PQ_query_param_end
  };
  enum GNUNET_DB_QueryStatus res;

  namecache_postgres_expire_blocks(plugin);
  GNUNET_CRYPTO_hash(&block->derived_key,
                     sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey),
                     &query);
  if (block_size > 64 * 65536)
    {
      GNUNET_break(0);
      return GNUNET_SYSERR;
    }
  delete_old_block(plugin,
                   &query,
                   block->expiration_time);

  res = GNUNET_PQ_eval_prepared_non_select(plugin->dbh,
                                           "cache_block",
                                           params);
  if (0 > res)
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

namecache_postgres_lookup_block()

static int namecache_postgres_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 245 of file plugin_namecache_postgres.c.

References bsize, Plugin::dbh, GNUNET_break, GNUNET_DB_STATUS_SUCCESS_NO_RESULTS, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_NO, GNUNET_OK, GNUNET_PQ_cleanup_result(), GNUNET_PQ_eval_prepared_singleton_select(), GNUNET_PQ_query_param_auto_from_type, GNUNET_PQ_query_param_end, GNUNET_PQ_result_spec_end, GNUNET_PQ_result_spec_variable_size(), GNUNET_SYSERR, Plugin::iter, LOG, plugin, GNUNET_GNSRECORD_Block::purpose, res, and GNUNET_CRYPTO_EccSignaturePurpose::size.

Referenced by libgnunet_plugin_namecache_postgres_init().

{
  struct Plugin *plugin = cls;
  size_t bsize;
  struct GNUNET_GNSRECORD_Block *block;
  struct GNUNET_PQ_QueryParam params[] = {
    GNUNET_PQ_query_param_auto_from_type(query),
    GNUNET_PQ_query_param_end
  };
  struct GNUNET_PQ_ResultSpec rs[] = {
    GNUNET_PQ_result_spec_variable_size("block",
                                        (void **)&block,
                                        &bsize),
    GNUNET_PQ_result_spec_end
  };
  enum GNUNET_DB_QueryStatus res;

  res = GNUNET_PQ_eval_prepared_singleton_select(plugin->dbh,
                                                 "lookup_block",
                                                 params,
                                                 rs);
  if (0 > res)
    {
      LOG(GNUNET_ERROR_TYPE_WARNING,
          "Failing lookup block in namecache (postgres error)\n");
      return GNUNET_SYSERR;
    }
  if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == res)
    {
      /* no result */
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Ending iteration (no more results)\n");
      return GNUNET_NO;
    }
  if ((bsize < sizeof(*block)) ||
      (bsize != ntohl(block->purpose.size) +
       sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey) +
       sizeof(struct GNUNET_CRYPTO_EcdsaSignature)))
    {
      GNUNET_break(0);
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Failing lookup (corrupt block)\n");
      GNUNET_PQ_cleanup_result(rs);
      return GNUNET_SYSERR;
    }
  iter(iter_cls,
       block);
  GNUNET_PQ_cleanup_result(rs);
  return GNUNET_OK;
}

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 307 of file plugin_namecache_postgres.c.

References Plugin::dbh.

Referenced by libgnunet_plugin_namecache_postgres_done(), and libgnunet_plugin_namecache_postgres_init().

{
  PQfinish(plugin->dbh);
  plugin->dbh = NULL;
}

Here is the caller graph for this function:

libgnunet_plugin_namecache_postgres_init()

void* libgnunet_plugin_namecache_postgres_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 321 of file plugin_namecache_postgres.c.

References Plugin::api, GNUNET_NAMECACHE_PluginFunctions::cache_block, Plugin::cfg, GNUNET_NAMECACHE_PluginFunctions::cls, database_setup(), database_shutdown(), GNUNET_ERROR_TYPE_INFO, GNUNET_new, GNUNET_OK, LOG, GNUNET_NAMECACHE_PluginFunctions::lookup_block, namecache_postgres_cache_block(), namecache_postgres_lookup_block(), and plugin.

{
  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_postgres_cache_block;
  api->lookup_block = &namecache_postgres_lookup_block;
  LOG(GNUNET_ERROR_TYPE_INFO,
      "Postgres namecache plugin running\n");
  return api;
}

Here is the call graph for this function:

libgnunet_plugin_namecache_postgres_done()

void* libgnunet_plugin_namecache_postgres_done

(

void *

cls

)

Exit point from the plugin.

Parameters

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

Returns

always NULL

Definition at line 353 of file plugin_namecache_postgres.c.

References Plugin::api, Plugin::cfg, GNUNET_NAMECACHE_PluginFunctions::cls, database_shutdown(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, LOG, and plugin.

{
  struct GNUNET_NAMECACHE_PluginFunctions *api = cls;
  struct Plugin *plugin = api->cls;

  database_shutdown(plugin);
  plugin->cfg = NULL;
  GNUNET_free(api);
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Postgres namecache plugin is finished\n");
  return NULL;
}

Here is the call graph for this function: