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:

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 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). More...

static enum GNUNET_GenericReturnValue	namestore_postgres_drop_tables (void *cls)
	Drop existing namestore tables. More...

static enum GNUNET_GenericReturnValue	database_prepare (struct Plugin *plugin)

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). More...

static enum GNUNET_GenericReturnValue	namestore_postgres_store_records (void cls, const struct GNUNET_CRYPTO_PrivateKey zone_key, const char label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data rd)
	Store a record in the datastore. More...

static void	parse_result_call_iterator (void cls, PGresult res, unsigned int num_results)
	A statement has been run. More...

static enum GNUNET_GenericReturnValue	namestore_postgres_lookup_records (void cls, const struct GNUNET_CRYPTO_PrivateKey zone, const char label, GNUNET_NAMESTORE_RecordIterator iter, void iter_cls)
	Lookup records in the datastore for which we are the authority. More...

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

static int	namestore_postgres_edit_records (void cls, const char editor_hint, const struct GNUNET_CRYPTO_PrivateKey zone, const char label, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
	Edit records in the datastore for which we are the authority. More...

static enum GNUNET_GenericReturnValue	namestore_postgres_iterate_records (void cls, const struct GNUNET_CRYPTO_PrivateKey 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. More...

static enum GNUNET_GenericReturnValue	namestore_postgres_zone_to_name (void cls, const struct GNUNET_CRYPTO_PrivateKey zone, const struct GNUNET_CRYPTO_PublicKey value_zone, GNUNET_NAMESTORE_RecordIterator iter, void iter_cls)
	Look for an existing PKEY delegation record for a given public key. More...

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. More...

void *	libgnunet_plugin_namestore_postgres_init (void *cls)
	Entry point for the plugin. More...

void *	libgnunet_plugin_namestore_postgres_done (void *cls)
	Exit point from the plugin. More...

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

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

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

References GNUNET_OK, GNUNET_PQ_connect_with_cfg(), GNUNET_PQ_disconnect(), GNUNET_SYSERR, and plugin.

Referenced by database_connect(), and libgnunet_plugin_namestore_postgres_init().

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

{
  struct Plugin *plugin = cls;
  struct GNUNET_PQ_Context *dbh;
  enum GNUNET_GenericReturnValue ret;
 
  dbh = GNUNET_PQ_connect_with_cfg (plugin->cfg,
                                    "namestore-postgres",
                                    NULL,
                                    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_connect_with_cfg(), GNUNET_PQ_disconnect(), GNUNET_PQ_exec_sql(), 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 114 of file plugin_namestore_postgres.c.

{
  enum GNUNET_GenericReturnValue ret;
 
  if (plugin->ready)
    return GNUNET_OK;
  {
    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
    };
 
    ret = GNUNET_PQ_prepare_statements (plugin->dbh,
                                        ps);
  }
  if (GNUNET_OK != ret)
    return ret;
  plugin->ready = true;
  return GNUNET_OK;
}

References GNUNET_OK, GNUNET_PQ_make_prepare(), GNUNET_PQ_prepare_statements(), GNUNET_PQ_PREPARED_STATEMENT_END, plugin, ps, and ret.

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

{
  struct GNUNET_PQ_ExecuteStatement ess[] = {
    GNUNET_PQ_make_try_execute ("SET synchronous_commit TO off"),
    GNUNET_PQ_EXECUTE_STATEMENT_END
  };
  struct GNUNET_PQ_ExecuteStatement *es;
 
  if (GNUNET_YES ==
      GNUNET_CONFIGURATION_get_value_yesno (plugin->cfg,
                                            "namestore-postgres",
                                            "ASYNC_COMMIT"))
    es = &ess[0];
  else
    es = &ess[1];
 
  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");
      return GNUNET_SYSERR;
    }
  }
  plugin->dbh = GNUNET_PQ_connect_with_cfg (plugin->cfg,
                                            "namestore-postgres",
                                            NULL,
                                            es,
                                            NULL);
  if (NULL == plugin->dbh)
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

References GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, GNUNET_PQ_connect_with_cfg(), GNUNET_PQ_EXECUTE_STATEMENT_END, GNUNET_PQ_make_try_execute(), GNUNET_SYSERR, GNUNET_YES, namestore_postgres_create_tables(), 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_store_records()

static enum GNUNET_GenericReturnValue namestore_postgres_store_records	(	void *	cls,
		const struct GNUNET_CRYPTO_PrivateKey *	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 233 of file plugin_namestore_postgres.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_CRYPTO_PublicKey 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 (GNUNET_CRYPTO_QUALITY_WEAK,
                                     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_QUALITY_WEAK, 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 372 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_PrivateKey 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_PrivateKey *	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 468 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_PrivateKey *	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 516 of file plugin_namestore_postgres.c.

{
 
  struct Plugin *plugin = cls;
  struct GNUNET_CRYPTO_PublicKey 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_PrivateKey *	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 563 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_PrivateKey *	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 616 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_PrivateKey *	zone,
		const struct GNUNET_CRYPTO_PublicKey *	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 684 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 722 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 742 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 762 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 783 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 799 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;
}

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 842 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:

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ LOG

Function Documentation

◆ namestore_postgres_create_tables()

◆ namestore_postgres_drop_tables()

◆ database_prepare()

◆ database_connect()

◆ namestore_postgres_store_records()

◆ parse_result_call_iterator()

◆ namestore_postgres_lookup_records()

◆ namestore_postgres_clear_editor_hint()

◆ namestore_postgres_edit_records()

◆ namestore_postgres_iterate_records()

◆ namestore_postgres_zone_to_name()

◆ namestore_postgres_begin_tx()

◆ namestore_postgres_commit_tx()

◆ namestore_postgres_rollback_tx()

◆ database_shutdown()

◆ libgnunet_plugin_namestore_postgres_init()

◆ libgnunet_plugin_namestore_postgres_done()