plugin_namestore_postgres.c File Reference

postgres-based namestore backend More...

#include "gnunet_db_lib.h"
#include "gnunet_namestore_plugin.h"
#include "gnunet_gnsrecord_lib.h"
#include "gnunet_pq_lib.h"

Include dependency graph for plugin_namestore_postgres.c:

Go to the source code of this file.

Data Structures
struct	Plugin
	Handle for a plugin. More...
struct	ParserContext
	Closure for parse_result_call_iterator. More...

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

Functions
static void	reconnect_cb (void *cls, struct GNUNET_PQ_Context *db)
	Function called whenever we (re) connect to db.
static enum GNUNET_GenericReturnValue	namestore_postgres_create_tables (void *cls)
	Initialize the database connections and associated data structures (create tables and indices as needed as well).
static enum GNUNET_GenericReturnValue	namestore_postgres_drop_tables (void *cls)
	Drop existing namestore tables.
static enum GNUNET_GenericReturnValue	database_prepare (struct Plugin *plugin)
static void	reconnect_setup (void *cls, struct GNUNET_PQ_Context *pq)
	Function called whenever we reconnect to the DB.
static enum GNUNET_GenericReturnValue	database_connect (struct Plugin *plugin)
	Initialize the database connections and associated data structures (create tables and indices as needed as well).
static enum GNUNET_GenericReturnValue	namestore_postgres_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 void	parse_result_call_iterator (void *cls, PGresult *res, unsigned int num_results)
	A statement has been run.
static enum GNUNET_GenericReturnValue	namestore_postgres_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	namestore_postgres_clear_editor_hint (void *cls, const char *editor_hint, const char *editor_hint_replacement, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, const char *label)
static int	namestore_postgres_edit_records (void *cls, const char *editor_hint, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, const char *label, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
	Edit records in the datastore for which we are the authority.
static enum GNUNET_GenericReturnValue	namestore_postgres_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 enum GNUNET_GenericReturnValue	namestore_postgres_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.
static int	namestore_postgres_begin_tx (void *cls)
static int	namestore_postgres_commit_tx (void *cls)
static int	namestore_postgres_rollback_tx (void *cls)
static void	database_shutdown (struct Plugin *plugin)
	Shutdown database connection and associate data structures.
void *	libgnunet_plugin_namestore_postgres_init (void *cls)
	Entry point for the plugin.
void *	libgnunet_plugin_namestore_postgres_done (void *cls)
	Exit point from the plugin.

Detailed Description

postgres-based namestore backend

Author

Christian Grothoff

Definition in file plugin_namestore_postgres.c.

Macro Definition Documentation

LOG

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

Definition at line 32 of file plugin_namestore_postgres.c.

Function Documentation

reconnect_cb()

static void reconnect_cb ( void *  cls, struct GNUNET_PQ_Context *  db  )

static

Function called whenever we (re) connect to db.

Initializes the schema.

Parameters

cls	NULL
db	database handle

Definition at line 65 of file plugin_namestore_postgres.c.

{
  GNUNET_break (GNUNET_OK !=
                GNUNET_PQ_run_sql (db,
                                   "namestore-"));
}

References db, GNUNET_break, GNUNET_OK, and GNUNET_PQ_run_sql().

Referenced by namestore_postgres_create_tables().

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_postgres_create_tables()

static enum GNUNET_GenericReturnValue namestore_postgres_create_tables ( void *  cls )

static

Initialize the database connections and associated data structures (create tables and indices as needed as well).

Parameters

cls	the plugin context (state for this module)

Returns

GNUNET_OK on success

Definition at line 82 of file plugin_namestore_postgres.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_PQ_Context *dbh;
 
  dbh = GNUNET_PQ_init (plugin->cfg,
                        "namestore-postgres",
                        &reconnect_cb,
                        NULL);
  if (NULL == dbh)
    return GNUNET_SYSERR;
  GNUNET_PQ_disconnect (dbh);
  return GNUNET_OK;
}

References GNUNET_OK, GNUNET_PQ_disconnect(), GNUNET_PQ_init(), GNUNET_SYSERR, plugin, and reconnect_cb().

Referenced by libgnunet_plugin_namestore_postgres_init(), and reconnect_setup().

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_postgres_drop_tables()

static enum GNUNET_GenericReturnValue namestore_postgres_drop_tables ( void *  cls )

static

Drop existing namestore tables.

Parameters

cls	the plugin context (state for this module)

Returns

GNUNET_OK on success

Definition at line 105 of file plugin_namestore_postgres.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_PQ_Context *dbh;
  enum GNUNET_GenericReturnValue ret;
 
  dbh = GNUNET_PQ_init (plugin->cfg,
                        "namestore-postgres",
                        NULL,
                        NULL);
  if (NULL == dbh)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to connect to database\n");
    return GNUNET_SYSERR;
  }
  ret = GNUNET_PQ_exec_sql (dbh,
                            "namestore-drop");
  GNUNET_PQ_disconnect (dbh);
  return ret;
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_PQ_disconnect(), GNUNET_PQ_exec_sql(), GNUNET_PQ_init(), GNUNET_SYSERR, plugin, and ret.

Referenced by libgnunet_plugin_namestore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

database_prepare()

static enum GNUNET_GenericReturnValue database_prepare ( struct Plugin *  plugin )

static

Definition at line 129 of file plugin_namestore_postgres.c.

{
  return (plugin->ready) ? GNUNET_OK : GNUNET_SYSERR;
}

References GNUNET_OK, GNUNET_SYSERR, and plugin.

Referenced by namestore_postgres_begin_tx(), namestore_postgres_clear_editor_hint(), namestore_postgres_commit_tx(), namestore_postgres_edit_records(), namestore_postgres_iterate_records(), namestore_postgres_lookup_records(), namestore_postgres_rollback_tx(), namestore_postgres_store_records(), and namestore_postgres_zone_to_name().

Here is the caller graph for this function:

reconnect_setup()

static void reconnect_setup ( void *  cls, struct GNUNET_PQ_Context *  pq  )

static

Function called whenever we reconnect to the DB.

Sets up the options, possibly the tables and the prepared statements.

Parameters

cls	the struct Plugin
pq	database handle

Definition at line 143 of file plugin_namestore_postgres.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_PQ_ExecuteStatement ess[] = {
    GNUNET_PQ_make_try_execute ("SET synchronous_commit TO off"),
    GNUNET_PQ_EXECUTE_STATEMENT_END
  };
  struct GNUNET_PQ_PreparedStatement ps[] = {
    GNUNET_PQ_make_prepare ("store_records",
                            "INSERT INTO namestore.ns098records"
                            " (zone_private_key, pkey, rvalue, record_count, record_data, label, editor_hint)"
                            " VALUES ($1, $2, $3, $4, $5, $6, '')"
                            " ON CONFLICT ON CONSTRAINT zl"
                            " DO UPDATE"
                            "    SET pkey=$2,rvalue=$3,record_count=$4,record_data=$5"
                            "    WHERE ns098records.zone_private_key = $1"
                            "          AND ns098records.label = $6"),
    GNUNET_PQ_make_prepare ("delete_records",
                            "DELETE FROM namestore.ns098records "
                            "WHERE zone_private_key=$1 AND label=$2"),
    GNUNET_PQ_make_prepare ("zone_to_name",
                            "SELECT seq,record_count,record_data,label,editor_hint FROM namestore.ns098records"
                            " WHERE zone_private_key=$1 AND pkey=$2"),
    GNUNET_PQ_make_prepare ("iterate_zone",
                            "SELECT seq,record_count,record_data,label,editor_hint FROM namestore.ns098records "
                            "WHERE zone_private_key=$1 AND seq > $2 ORDER BY seq ASC LIMIT $3"),
    GNUNET_PQ_make_prepare ("iterate_all_zones",
                            "SELECT seq,record_count,record_data,label,editor_hint,zone_private_key"
                            " FROM namestore.ns098records WHERE seq > $1 ORDER BY seq ASC LIMIT $2")
    ,
    GNUNET_PQ_make_prepare ("lookup_label",
                            "SELECT seq,record_count,record_data,label,editor_hint "
                            "FROM namestore.ns098records WHERE zone_private_key=$1 AND label=$2"),
    GNUNET_PQ_make_prepare ("edit_set",
                            "UPDATE namestore.ns098records x"
                            " SET editor_hint=$3"
                            " FROM ("
                            " SELECT * FROM namestore.ns098records"
                            " WHERE ns098records.zone_private_key=$1 AND ns098records.label=$2 FOR UPDATE) y"
                            " WHERE x.zone_private_key = y.zone_private_key AND"
                            " x.label = y.label"
                            " RETURNING x.seq,x.record_count,x.record_data,x.label,y.editor_hint "),
    GNUNET_PQ_make_prepare ("clear_editor_hint",
                            "UPDATE namestore.ns098records"
                            " SET editor_hint=$4"
                            " WHERE zone_private_key=$1 AND label=$2 AND editor_hint=$3"),
    GNUNET_PQ_PREPARED_STATEMENT_END
  };
 
  if (GNUNET_YES ==
      GNUNET_CONFIGURATION_get_value_yesno (plugin->cfg,
                                            "namestore-postgres",
                                            "ASYNC_COMMIT"))
  {
    GNUNET_break (GNUNET_OK ==
                  GNUNET_PQ_exec_statements (pq,
                                             ess));
  }
 
  if (GNUNET_YES ==
      GNUNET_CONFIGURATION_get_value_yesno (plugin->cfg,
                                            "namestore-postgres",
                                            "INIT_ON_CONNECT"))
  {
    if (GNUNET_OK !=
        namestore_postgres_create_tables (plugin))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to create tables\n");
      plugin->ready = false;
      return;
    }
  }
  if (GNUNET_OK !=
      GNUNET_PQ_prepare_statements (pq,
                                    ps))
  {
    plugin->ready = false;
    return;
  }
  plugin->ready = true;
}

References GNUNET_break, GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, GNUNET_PQ_exec_statements(), GNUNET_PQ_EXECUTE_STATEMENT_END, GNUNET_PQ_make_prepare(), GNUNET_PQ_make_try_execute(), GNUNET_PQ_prepare_statements(), GNUNET_PQ_PREPARED_STATEMENT_END, GNUNET_YES, namestore_postgres_create_tables(), plugin, and ps.

Referenced by database_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

database_connect()

static enum GNUNET_GenericReturnValue database_connect ( 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 237 of file plugin_namestore_postgres.c.

{
  plugin->dbh = GNUNET_PQ_init (plugin->cfg,
                                "namestore-postgres",
                                &reconnect_setup,
                                plugin);
  if (NULL == plugin->dbh)
    return GNUNET_SYSERR;
  if (! plugin->ready)
    return GNUNET_NO;
  return GNUNET_OK;
}

References GNUNET_NO, GNUNET_OK, GNUNET_PQ_init(), GNUNET_SYSERR, plugin, and reconnect_setup().

Referenced by libgnunet_plugin_namestore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_postgres_store_records()

static enum GNUNET_GenericReturnValue namestore_postgres_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 263 of file plugin_namestore_postgres.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_CRYPTO_BlindablePublicKey pkey;
  uint64_t rvalue;
  uint32_t rd_count32 = (uint32_t) rd_count;
  ssize_t data_size;
 
  GNUNET_assert (GNUNET_OK == database_prepare (plugin));
  memset (&pkey,
          0,
          sizeof(pkey));
  for (unsigned int i = 0; i < rd_count; i++)
    if (GNUNET_YES ==
        GNUNET_GNSRECORD_is_zonekey_type (rd[i].record_type))
    {
      GNUNET_break (GNUNET_OK ==
                    GNUNET_GNSRECORD_identity_from_data (rd[i].data,
                                                         rd[i].data_size,
                                                         rd[i].record_type,
                                                         &pkey));
      break;
    }
  rvalue = GNUNET_CRYPTO_random_u64 (UINT64_MAX);
  data_size = GNUNET_GNSRECORD_records_get_size (rd_count,
                                                 rd);
  if (data_size < 0)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (data_size >= UINT16_MAX)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  /* if record set is empty, delete existing records */
  if (0 == rd_count)
  {
    struct GNUNET_PQ_QueryParam params[] = {
      GNUNET_PQ_query_param_auto_from_type (zone_key),
      GNUNET_PQ_query_param_string (label),
      GNUNET_PQ_query_param_end
    };
    enum GNUNET_DB_QueryStatus res;
 
    res = GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
                                              "delete_records",
                                              params);
    if ((GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != res) &&
        (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS != res))
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                     "postgres",
                     "Record deleted\n");
    return GNUNET_OK;
  }
  /* otherwise, UPSERT (i.e. UPDATE if exists, otherwise INSERT) */
  {
    char data[data_size];
    struct GNUNET_PQ_QueryParam params[] = {
      GNUNET_PQ_query_param_auto_from_type (zone_key),
      GNUNET_PQ_query_param_auto_from_type (&pkey),
      GNUNET_PQ_query_param_uint64 (&rvalue),
      GNUNET_PQ_query_param_uint32 (&rd_count32),
      GNUNET_PQ_query_param_fixed_size (data, data_size),
      GNUNET_PQ_query_param_string (label),
      GNUNET_PQ_query_param_end
    };
    enum GNUNET_DB_QueryStatus res;
    ssize_t ret;
 
    ret = GNUNET_GNSRECORD_records_serialize (rd_count,
                                              rd,
                                              data_size,
                                              data);
    if ((ret < 0) ||
        (data_size != ret))
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
 
    res = GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
                                              "store_records",
                                              params);
    if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != res)
      return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References data, data_size, database_prepare(), GNUNET_assert, GNUNET_break, GNUNET_CRYPTO_random_u64(), GNUNET_DB_STATUS_SUCCESS_NO_RESULTS, GNUNET_DB_STATUS_SUCCESS_ONE_RESULT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_identity_from_data(), GNUNET_GNSRECORD_is_zonekey_type(), GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_records_serialize(), GNUNET_log_from, GNUNET_OK, GNUNET_PQ_eval_prepared_non_select(), GNUNET_PQ_query_param_auto_from_type, GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_fixed_size(), GNUNET_PQ_query_param_string(), GNUNET_PQ_query_param_uint32(), GNUNET_PQ_query_param_uint64(), GNUNET_SYSERR, GNUNET_YES, pkey, plugin, rd, rd_count, res, and ret.

Referenced by libgnunet_plugin_namestore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_result_call_iterator()

static void parse_result_call_iterator ( void *  cls, PGresult *  res, unsigned int  num_results  )

static

A statement has been run.

We should evaluate the result, and if possible call the iter in cls with the result.

Parameters

cls	closure of type struct ParserContext *
res	the postgres result
num_results	the number of results in result

Definition at line 401 of file plugin_namestore_postgres.c.

{
  struct ParserContext *pc = cls;
 
  if (NULL == pc->iter)
    return;   /* no need to do more work */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got %d results from PQ.\n", num_results);
  for (unsigned int i = 0; i < num_results; i++)
  {
    uint64_t serial;
    void *data;
    size_t data_size;
    uint32_t record_count;
    char *label;
    char *editor_hint;
    struct GNUNET_CRYPTO_BlindablePrivateKey zk;
    struct GNUNET_PQ_ResultSpec rs_with_zone[] = {
      GNUNET_PQ_result_spec_uint64 ("seq", &serial),
      GNUNET_PQ_result_spec_uint32 ("record_count", &record_count),
      GNUNET_PQ_result_spec_variable_size ("record_data", &data, &data_size),
      GNUNET_PQ_result_spec_string ("label", &label),
      GNUNET_PQ_result_spec_string ("editor_hint", &editor_hint),
      GNUNET_PQ_result_spec_auto_from_type ("zone_private_key", &zk),
      GNUNET_PQ_result_spec_end
    };
    struct GNUNET_PQ_ResultSpec rs_without_zone[] = {
      GNUNET_PQ_result_spec_uint64 ("seq", &serial),
      GNUNET_PQ_result_spec_uint32 ("record_count", &record_count),
      GNUNET_PQ_result_spec_variable_size ("record_data", &data, &data_size),
      GNUNET_PQ_result_spec_string ("label", &label),
      GNUNET_PQ_result_spec_string ("editor_hint", &editor_hint),
      GNUNET_PQ_result_spec_end
    };
    struct GNUNET_PQ_ResultSpec *rs;
 
    rs = (NULL == pc->zone_key) ? rs_with_zone : rs_without_zone;
    if (GNUNET_YES !=
        GNUNET_PQ_extract_result (res,
                                  rs,
                                  i))
    {
      GNUNET_break (0);
      return;
    }
 
    if (record_count > 64 * 1024)
    {
      /* sanity check, don't stack allocate far too much just
         because database might contain a large value here */
      GNUNET_break (0);
      GNUNET_PQ_cleanup_result (rs);
      return;
    }
 
    {
      struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL (record_count)];
 
      GNUNET_assert (0 != serial);
      if (GNUNET_OK !=
          GNUNET_GNSRECORD_records_deserialize (data_size,
                                                data,
                                                record_count,
                                                rd))
      {
        GNUNET_break (0);
        GNUNET_PQ_cleanup_result (rs);
        return;
      }
      pc->iter (pc->iter_cls,
                serial,
                editor_hint,
                (NULL == pc->zone_key) ? &zk : pc->zone_key,
                label,
                record_count,
                rd);
    }
    GNUNET_PQ_cleanup_result (rs);
  }
  pc->limit -= num_results;
}

References data, data_size, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_records_deserialize(), GNUNET_NZL, GNUNET_OK, GNUNET_PQ_cleanup_result(), GNUNET_PQ_extract_result(), GNUNET_PQ_result_spec_auto_from_type, GNUNET_PQ_result_spec_end, GNUNET_PQ_result_spec_string(), GNUNET_PQ_result_spec_uint32(), GNUNET_PQ_result_spec_uint64(), GNUNET_PQ_result_spec_variable_size(), GNUNET_YES, LOG, pc, rd, record_count, and res.

Referenced by namestore_postgres_edit_records(), namestore_postgres_iterate_records(), namestore_postgres_lookup_records(), and namestore_postgres_zone_to_name().

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_postgres_lookup_records()

static enum GNUNET_GenericReturnValue namestore_postgres_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 497 of file plugin_namestore_postgres.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_PQ_QueryParam params[] = {
    GNUNET_PQ_query_param_auto_from_type (zone),
    GNUNET_PQ_query_param_string (label),
    GNUNET_PQ_query_param_end
  };
  struct ParserContext pc;
  enum GNUNET_DB_QueryStatus res;
  GNUNET_assert (GNUNET_OK == database_prepare (plugin));
 
  if (NULL == zone)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  pc.iter = iter;
  pc.iter_cls = iter_cls;
  pc.zone_key = zone;
  res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
                                              "lookup_label",
                                              params,
                                              &parse_result_call_iterator,
                                              &pc);
  if (res < 0)
    return GNUNET_SYSERR;
  if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == res)
    return GNUNET_NO;
  return GNUNET_OK;
}

References database_prepare(), GNUNET_assert, GNUNET_break, GNUNET_DB_STATUS_SUCCESS_NO_RESULTS, GNUNET_NO, GNUNET_OK, GNUNET_PQ_eval_prepared_multi_select(), GNUNET_PQ_query_param_auto_from_type, GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_string(), GNUNET_SYSERR, ParserContext::iter, ParserContext::iter_cls, parse_result_call_iterator(), pc, plugin, and res.

Referenced by libgnunet_plugin_namestore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_postgres_clear_editor_hint()

static int namestore_postgres_clear_editor_hint ( void *  cls, const char *  editor_hint, const char *  editor_hint_replacement, const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone, const char *  label  )

static

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 545 of file plugin_namestore_postgres.c.

{
 
  struct Plugin *plugin = cls;
  struct GNUNET_CRYPTO_BlindablePublicKey pkey;
 
  GNUNET_assert (GNUNET_OK == database_prepare (plugin));
  memset (&pkey,
          0,
          sizeof(pkey));
  {
    struct GNUNET_PQ_QueryParam params[] = {
      GNUNET_PQ_query_param_auto_from_type (zone),
      GNUNET_PQ_query_param_string (label),
      GNUNET_PQ_query_param_string (editor_hint),
      GNUNET_PQ_query_param_string (editor_hint_replacement),
      GNUNET_PQ_query_param_end
    };
    enum GNUNET_DB_QueryStatus res;
 
    res = GNUNET_PQ_eval_prepared_non_select (plugin->dbh,
                                              "clear_editor_hint",
                                              params);
    if ((GNUNET_DB_STATUS_SUCCESS_NO_RESULTS != res) &&
        (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != res))
      return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References database_prepare(), GNUNET_assert, GNUNET_DB_STATUS_SUCCESS_NO_RESULTS, GNUNET_DB_STATUS_SUCCESS_ONE_RESULT, GNUNET_OK, GNUNET_PQ_eval_prepared_non_select(), GNUNET_PQ_query_param_auto_from_type, GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_string(), GNUNET_SYSERR, pkey, plugin, and res.

Referenced by libgnunet_plugin_namestore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_postgres_edit_records()

static int namestore_postgres_edit_records ( void *  cls, const char *  editor_hint, const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone, const char *  label, GNUNET_NAMESTORE_RecordIterator  iter, void *  iter_cls  )

static

Edit 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 592 of file plugin_namestore_postgres.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_PQ_QueryParam params[] = {
    GNUNET_PQ_query_param_auto_from_type (zone),
    GNUNET_PQ_query_param_string (label),
    GNUNET_PQ_query_param_string (editor_hint),
    GNUNET_PQ_query_param_end
  };
  struct ParserContext pc;
  enum GNUNET_DB_QueryStatus res;
  GNUNET_assert (GNUNET_OK == database_prepare (plugin));
 
  if (NULL == zone)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  pc.iter = iter;
  pc.iter_cls = iter_cls;
  pc.zone_key = zone;
  res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
                                              "edit_set",
                                              params,
                                              &parse_result_call_iterator,
                                              &pc);
  if (res < 0)
    return GNUNET_SYSERR;
  if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == res)
    return GNUNET_NO;
  return GNUNET_OK;
}

References database_prepare(), GNUNET_assert, GNUNET_break, GNUNET_DB_STATUS_SUCCESS_NO_RESULTS, GNUNET_NO, GNUNET_OK, GNUNET_PQ_eval_prepared_multi_select(), GNUNET_PQ_query_param_auto_from_type, GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_string(), GNUNET_SYSERR, ParserContext::iter, ParserContext::iter_cls, parse_result_call_iterator(), pc, plugin, and res.

Referenced by libgnunet_plugin_namestore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_postgres_iterate_records()

static enum GNUNET_GenericReturnValue namestore_postgres_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 fetch
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 645 of file plugin_namestore_postgres.c.

{
  struct Plugin *plugin = cls;
  enum GNUNET_DB_QueryStatus res;
  struct ParserContext pc;
 
  GNUNET_assert (GNUNET_OK == database_prepare (plugin));
  pc.iter = iter;
  pc.iter_cls = iter_cls;
  pc.zone_key = zone;
  pc.limit = limit;
  if (NULL == zone)
  {
    struct GNUNET_PQ_QueryParam params_without_zone[] = {
      GNUNET_PQ_query_param_uint64 (&serial),
      GNUNET_PQ_query_param_uint64 (&limit),
      GNUNET_PQ_query_param_end
    };
 
    res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
                                                "iterate_all_zones",
                                                params_without_zone,
                                                &parse_result_call_iterator,
                                                &pc);
  }
  else
  {
    struct GNUNET_PQ_QueryParam params_with_zone[] = {
      GNUNET_PQ_query_param_auto_from_type (zone),
      GNUNET_PQ_query_param_uint64 (&serial),
      GNUNET_PQ_query_param_uint64 (&limit),
      GNUNET_PQ_query_param_end
    };
 
    res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
                                                "iterate_zone",
                                                params_with_zone,
                                                &parse_result_call_iterator,
                                                &pc);
  }
  if (res < 0)
    return GNUNET_SYSERR;
 
  if ((GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == res) ||
      (pc.limit > 0))
    return GNUNET_NO;
  return GNUNET_OK;
}

References database_prepare(), GNUNET_assert, GNUNET_DB_STATUS_SUCCESS_NO_RESULTS, GNUNET_NO, GNUNET_OK, GNUNET_PQ_eval_prepared_multi_select(), GNUNET_PQ_query_param_auto_from_type, GNUNET_PQ_query_param_end, GNUNET_PQ_query_param_uint64(), GNUNET_SYSERR, ParserContext::iter, ParserContext::iter_cls, ParserContext::limit, parse_result_call_iterator(), pc, plugin, and res.

Referenced by libgnunet_plugin_namestore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_postgres_zone_to_name()

static enum GNUNET_GenericReturnValue namestore_postgres_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 713 of file plugin_namestore_postgres.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_PQ_QueryParam params[] = {
    GNUNET_PQ_query_param_auto_from_type (zone),
    GNUNET_PQ_query_param_auto_from_type (value_zone),
    GNUNET_PQ_query_param_end
  };
  enum GNUNET_DB_QueryStatus res;
  struct ParserContext pc;
  GNUNET_assert (GNUNET_OK == database_prepare (plugin));
 
  pc.iter = iter;
  pc.iter_cls = iter_cls;
  pc.zone_key = zone;
  res = GNUNET_PQ_eval_prepared_multi_select (plugin->dbh,
                                              "zone_to_name",
                                              params,
                                              &parse_result_call_iterator,
                                              &pc);
  if (res < 0)
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

References database_prepare(), GNUNET_assert, GNUNET_OK, GNUNET_PQ_eval_prepared_multi_select(), GNUNET_PQ_query_param_auto_from_type, GNUNET_PQ_query_param_end, GNUNET_SYSERR, ParserContext::iter, ParserContext::iter_cls, parse_result_call_iterator(), pc, plugin, and res.

Referenced by libgnunet_plugin_namestore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_postgres_begin_tx()

static int namestore_postgres_begin_tx ( void *  cls )

static

Parameters

cls	closure (internal context for the plugin)

Returns

GNUNET_OK on success, GNUNET_NO for no results, else GNUNET_SYSERR

Definition at line 751 of file plugin_namestore_postgres.c.

{
 
  struct Plugin *plugin = cls;
 
  struct GNUNET_PQ_ExecuteStatement ess[] = {
    GNUNET_PQ_make_try_execute ("BEGIN"),
    GNUNET_PQ_EXECUTE_STATEMENT_END
  };
  GNUNET_assert (GNUNET_OK == database_prepare (plugin));
  return GNUNET_PQ_exec_statements (plugin->dbh, ess);
}

References database_prepare(), GNUNET_assert, GNUNET_OK, GNUNET_PQ_exec_statements(), GNUNET_PQ_EXECUTE_STATEMENT_END, GNUNET_PQ_make_try_execute(), and plugin.

Referenced by libgnunet_plugin_namestore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_postgres_commit_tx()

static int namestore_postgres_commit_tx ( void *  cls )

static

Parameters

cls	closure (internal context for the plugin)

Returns

GNUNET_OK on success, GNUNET_NO for no results, else GNUNET_SYSERR

Definition at line 771 of file plugin_namestore_postgres.c.

{
 
  struct Plugin *plugin = cls;
 
  struct GNUNET_PQ_ExecuteStatement ess[] = {
    GNUNET_PQ_make_try_execute ("COMMIT"),
    GNUNET_PQ_EXECUTE_STATEMENT_END
  };
  GNUNET_assert (GNUNET_OK == database_prepare (plugin));
  return GNUNET_PQ_exec_statements (plugin->dbh, ess);
}

References database_prepare(), GNUNET_assert, GNUNET_OK, GNUNET_PQ_exec_statements(), GNUNET_PQ_EXECUTE_STATEMENT_END, GNUNET_PQ_make_try_execute(), and plugin.

Referenced by libgnunet_plugin_namestore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_postgres_rollback_tx()

static int namestore_postgres_rollback_tx ( void *  cls )

static

Parameters

cls	closure (internal context for the plugin)

Returns

GNUNET_OK on success, GNUNET_NO for no results, else GNUNET_SYSERR

Definition at line 791 of file plugin_namestore_postgres.c.

{
 
  struct Plugin *plugin = cls;
 
  struct GNUNET_PQ_ExecuteStatement ess[] = {
    GNUNET_PQ_make_try_execute ("ROLLBACK"),
    GNUNET_PQ_EXECUTE_STATEMENT_END
  };
  GNUNET_assert (GNUNET_OK == database_prepare (plugin));
  return GNUNET_PQ_exec_statements (plugin->dbh, ess);
}

References database_prepare(), GNUNET_assert, GNUNET_OK, GNUNET_PQ_exec_statements(), GNUNET_PQ_EXECUTE_STATEMENT_END, GNUNET_PQ_make_try_execute(), and plugin.

Referenced by libgnunet_plugin_namestore_postgres_init().

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 812 of file plugin_namestore_postgres.c.

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

References GNUNET_PQ_disconnect(), and plugin.

Referenced by libgnunet_plugin_namestore_postgres_done(), and libgnunet_plugin_namestore_postgres_init().

Here is the call graph for this function:

Here is the caller graph for this function:

libgnunet_plugin_namestore_postgres_init()

void * libgnunet_plugin_namestore_postgres_init

(

void *

cls

)

Entry point for the plugin.

Parameters

cls	the struct GNUNET_NAMESTORE_PluginEnvironment*

Returns

NULL on error, othrewise the plugin context

Definition at line 828 of file plugin_namestore_postgres.c.

{
  struct Plugin *plugin;
  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
  struct GNUNET_NAMESTORE_PluginFunctions *api;
 
  plugin = GNUNET_new (struct Plugin);
  plugin->cfg = cfg;
  if (GNUNET_OK != database_connect (plugin))
  {
    database_shutdown (plugin);
    GNUNET_free (plugin);
    return NULL;
  }
  api = GNUNET_new (struct GNUNET_NAMESTORE_PluginFunctions);
  api->cls = plugin;
  api->create_tables = &namestore_postgres_create_tables;
  api->drop_tables = &namestore_postgres_drop_tables;
  api->store_records = &namestore_postgres_store_records;
  api->iterate_records = &namestore_postgres_iterate_records;
  api->zone_to_name = &namestore_postgres_zone_to_name;
  api->lookup_records = &namestore_postgres_lookup_records;
  api->edit_records = &namestore_postgres_edit_records;
  api->clear_editor_hint = &namestore_postgres_clear_editor_hint;
  api->begin_tx = &namestore_postgres_begin_tx;
  api->commit_tx = &namestore_postgres_commit_tx;
  api->rollback_tx = &namestore_postgres_rollback_tx;
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Postgres namestore plugin running\n");
  return api;
}

References GNUNET_NAMESTORE_PluginFunctions::begin_tx, cfg, GNUNET_NAMESTORE_PluginFunctions::clear_editor_hint, GNUNET_NAMESTORE_PluginFunctions::cls, GNUNET_NAMESTORE_PluginFunctions::commit_tx, GNUNET_NAMESTORE_PluginFunctions::create_tables, database_connect(), database_shutdown(), GNUNET_NAMESTORE_PluginFunctions::drop_tables, GNUNET_NAMESTORE_PluginFunctions::edit_records, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_new, GNUNET_OK, GNUNET_NAMESTORE_PluginFunctions::iterate_records, LOG, GNUNET_NAMESTORE_PluginFunctions::lookup_records, namestore_postgres_begin_tx(), namestore_postgres_clear_editor_hint(), namestore_postgres_commit_tx(), namestore_postgres_create_tables(), namestore_postgres_drop_tables(), namestore_postgres_edit_records(), namestore_postgres_iterate_records(), namestore_postgres_lookup_records(), namestore_postgres_rollback_tx(), namestore_postgres_store_records(), namestore_postgres_zone_to_name(), plugin, GNUNET_NAMESTORE_PluginFunctions::rollback_tx, GNUNET_NAMESTORE_PluginFunctions::store_records, and GNUNET_NAMESTORE_PluginFunctions::zone_to_name.

Here is the call graph for this function:

libgnunet_plugin_namestore_postgres_done()

void * libgnunet_plugin_namestore_postgres_done

(

void *

cls

)

Exit point from the plugin.

Parameters

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

Returns

always NULL

Definition at line 871 of file plugin_namestore_postgres.c.

{
  struct GNUNET_NAMESTORE_PluginFunctions *api = cls;
  struct Plugin *plugin = api->cls;
 
  database_shutdown (plugin);
  plugin->cfg = NULL;
  GNUNET_free (plugin);
  GNUNET_free (api);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Postgres namestore 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, LOG, and plugin.

Here is the call graph for this function: