postgres-based namestore backend More...

#include "platform.h"
#include "gnunet_namestore_plugin.h"
#include "gnunet_namestore_service.h"
#include "gnunet_gnsrecord_lib.h"
#include "gnunet_pq_lib.h"
#include "namestore.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_IDENTITY_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	lookup_records (void cls, const struct GNUNET_IDENTITY_PrivateKey zone, const char label, GNUNET_NAMESTORE_RecordIterator iter, void iter_cls, const char *method)
	Lookup records in the datastore for which we are the authority. More...

static enum GNUNET_GenericReturnValue	namestore_postgres_lookup_records (void cls, const struct GNUNET_IDENTITY_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_edit_records (void cls, const struct GNUNET_IDENTITY_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_IDENTITY_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_IDENTITY_PrivateKey zone, const struct GNUNET_IDENTITY_PublicKey value_zone, GNUNET_NAMESTORE_RecordIterator iter, void iter_cls)
	Look for an existing PKEY delegation record for a given public key. More...

static enum GNUNET_GenericReturnValue	namestore_postgres_transaction_begin (void cls, char *emsg)
	Begin a transaction for a client. More...

static enum GNUNET_GenericReturnValue	namestore_postgres_transaction_rollback (void cls, char *emsg)
	Commit a transaction for a client. More...

static enum GNUNET_GenericReturnValue	namestore_postgres_transaction_commit (void cls, char *emsg)
	Roll back a transaction for a client. More...

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 34 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 1 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;
 }

Referenced by libgnunet_plugin_namestore_postgres_init().

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 1 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;
 }

Referenced by libgnunet_plugin_namestore_postgres_init().

Here is the caller graph for this function:

◆ database_prepare()

static enum GNUNET_GenericReturnValue database_prepare ( struct Plugin * plugin )

static

Definition at line 1 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)"
                               " 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 FROM namestore.ns098records"
                               " WHERE zone_private_key=$1 AND pkey=$2"),
       GNUNET_PQ_make_prepare ("iterate_zone",
                               "SELECT seq,record_count,record_data,label 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,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 "
                               "FROM namestore.ns098records WHERE zone_private_key=$1 AND label=$2"),
       GNUNET_PQ_make_prepare ("edit_set",
                               "SELECT seq,record_count,record_data,label "
                               "FROM namestore.ns098records WHERE zone_private_key=$1 AND label=$2 FOR UPDATE NOWAIT"),
       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;
 }

◆ 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 1 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;
 }

Referenced by libgnunet_plugin_namestore_postgres_init().

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

 {
   struct Plugin *plugin = cls;
   struct GNUNET_IDENTITY_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;
 }

Referenced by libgnunet_plugin_namestore_postgres_init().

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 364 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;
     struct GNUNET_IDENTITY_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_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_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,
                 (NULL == pc->zone_key) ? &zk : pc->zone_key,
                 label,
                 record_count,
                 rd);
     }
     GNUNET_PQ_cleanup_result (rs);
   }
   pc->limit -= num_results;
 }

◆ lookup_records()

static enum GNUNET_GenericReturnValue lookup_records	(	void *	cls,
		const struct GNUNET_IDENTITY_PrivateKey *	zone,
		const char *	label,
		GNUNET_NAMESTORE_RecordIterator	iter,
		void *	iter_cls,
		const char *	method
	)

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
method	the method to use "lookup_record" or "edit_set"

Returns: GNUNET_OK on success, GNUNET_NO for no results, else GNUNET_SYSERR

Definition at line 364 of file plugin_namestore_postgres.c.

 {
   struct Plugin *plugin = cls;
   GNUNET_assert (GNUNET_OK == database_prepare (plugin));
   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;
  
   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,
                                               method,
                                               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 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().

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

 {
   return lookup_records (cls, zone, label, iter, iter_cls, "lookup_label");
 }

Referenced by libgnunet_plugin_namestore_postgres_init().

Here is the caller graph for this function:

◆ namestore_postgres_edit_records()

static int namestore_postgres_edit_records	(	void *	cls,
		const struct GNUNET_IDENTITY_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 529 of file plugin_namestore_postgres.c.

 {
   return lookup_records (cls, zone, label, iter, iter_cls, "edit_set");
 }

References ParserContext::iter, ParserContext::iter_cls, lookup_records(), and zone.

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_IDENTITY_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 529 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;
 }

Referenced by libgnunet_plugin_namestore_postgres_init().

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_IDENTITY_PrivateKey *	zone,
		const struct GNUNET_IDENTITY_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 529 of file plugin_namestore_postgres.c.

 {
   struct Plugin *plugin = cls;
   GNUNET_assert (GNUNET_OK == database_prepare (plugin));
   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;
  
   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;
 }

Referenced by libgnunet_plugin_namestore_postgres_init().

Here is the caller graph for this function:

◆ namestore_postgres_transaction_begin()

static enum GNUNET_GenericReturnValue namestore_postgres_transaction_begin	(	void *	cls,
		char **	emsg
	)

static

Begin a transaction for a client.

Parameters

cls	closure (internal context for the plugin)
emsg	error message set of return code is GNUNET_SYSERR

Returns: GNUNET_YES on success, GNUNET_SYSERR if transaction cannot be started.

Definition at line 529 of file plugin_namestore_postgres.c.

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

Referenced by libgnunet_plugin_namestore_postgres_init().

Here is the caller graph for this function:

◆ namestore_postgres_transaction_rollback()

static enum GNUNET_GenericReturnValue namestore_postgres_transaction_rollback	(	void *	cls,
		char **	emsg
	)

static

Commit a transaction for a client.

This releases the lock on the database.

Parameters

cls	closure (internal context for the plugin)
emsg	error message set of return code is GNUNET_SYSERR

Returns: GNUNET_YES on success, GNUNET_SYSERR if transaction cannot be started.

Definition at line 529 of file plugin_namestore_postgres.c.

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

Referenced by libgnunet_plugin_namestore_postgres_init().

Here is the caller graph for this function:

◆ namestore_postgres_transaction_commit()

static enum GNUNET_GenericReturnValue namestore_postgres_transaction_commit	(	void *	cls,
		char **	emsg
	)

static

Roll back a transaction for a client.

This releases the lock on the database.

Parameters

cls	closure (internal context for the plugin)
emsg	error message set of return code is GNUNET_SYSERR

Returns: GNUNET_YES on success, GNUNET_SYSERR if transaction cannot be started.

Definition at line 529 of file plugin_namestore_postgres.c.

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

Referenced by libgnunet_plugin_namestore_postgres_init().

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 728 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 742 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->transaction_begin = &namestore_postgres_transaction_begin;
   api->transaction_commit = &namestore_postgres_transaction_commit;
   api->transaction_rollback = &namestore_postgres_transaction_rollback;
   api->edit_records = &namestore_postgres_edit_records;
   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 781 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()

◆ lookup_records()

◆ namestore_postgres_lookup_records()

◆ namestore_postgres_edit_records()

◆ namestore_postgres_iterate_records()

◆ namestore_postgres_zone_to_name()

◆ namestore_postgres_transaction_begin()

◆ namestore_postgres_transaction_rollback()

◆ namestore_postgres_transaction_commit()

◆ database_shutdown()

◆ libgnunet_plugin_namestore_postgres_init()

◆ libgnunet_plugin_namestore_postgres_done()