gnunet_pq_lib.h File Reference

helper functions for Postgres DB interactions More...

#include <libpq-fe.h>
#include <stdint.h>
#include "gnunet_common.h"
#include "gnunet_time_lib.h"
#include "gnunet_util_lib.h"
#include "gnunet_db_lib.h"
#include "postgres_ext.h"

Include dependency graph for gnunet_pq_lib.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	GNUNET_PQ_QueryParam
	Description of a DB query parameter. More...
struct	GNUNET_PQ_ArrayHeader_P
	The header for a postgresql array in binary format. More...
struct	GNUNET_PQ_ResultSpec
	Description of a DB result cell. More...
struct	GNUNET_PQ_PreparedStatement
	Information needed to prepare a list of SQL statements using GNUNET_PQ_prepare_statements(). More...
struct	GNUNET_PQ_ExecuteStatement
	Information needed to run a list of SQL statements using GNUNET_PQ_exec_statements(). More...

Macros
#define	GNUNET_PQ_query_param_end
	End of query parameter specification. More...
#define	GNUNET_PQ_query_param_array_auto_from_type(num, elements, db)
	Generate array of equal-sized query parameter with size determined by variable type from a pointer to an continuous array. More...
#define	GNUNET_PQ_query_param_array_ptrs_auto_from_type(num, elements, db)
	Generate array of equal-sized query parameter with size determined by variable type from a pointer to an array of pointers to objects of the same type. More...
#define	GNUNET_PQ_query_param_auto_from_type(x)    GNUNET_PQ_query_param_fixed_size ((x), sizeof(*(x)))
	Generate fixed-size query parameter with size determined by variable type. More...
#define	GNUNET_PQ_result_spec_end
	End of result parameter specification. More...
#define	GNUNET_PQ_result_spec_auto_from_type(name, dst)    GNUNET_PQ_result_spec_fixed_size (name, (dst), sizeof(*(dst)))
	We expect a fixed-size result, with size determined by the type of * dst More...
#define	GNUNET_PQ_result_spec_auto_array_from_type(db, name, num, dst)
	We expect a fixed-size result, with size determined by the type of * dst More...
#define	GNUNET_PQ_PREPARED_STATEMENT_END
	Terminator for prepared statement list. More...
#define	GNUNET_PQ_EXECUTE_STATEMENT_END
	Terminator for executable statement list. More...

Typedefs
typedef int(*	GNUNET_PQ_QueryConverter) (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
	Function called to convert input argument into SQL parameters. More...
typedef void(*	GNUNET_PQ_QueryConverter_Cleanup) (void *cls)
	Function called to cleanup the closure of SQL parameters converter. More...
typedef enum GNUNET_GenericReturnValue(*	GNUNET_PQ_ResultConverter) (void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)
	Extract data from a Postgres database result at row row. More...
typedef void(*	GNUNET_PQ_ResultCleanup) (void *cls, void *rd)
	Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter. More...
typedef void(*	GNUNET_PQ_PostgresResultHandler) (void *cls, PGresult *result, unsigned int num_results)
	Function to be called with the results of a SELECT statement that has returned num_results results. More...

Enumerations
enum	GNUNET_PQ_Options { GNUNET_PQ_FLAG_NONE = 0 , GNUNET_PQ_FLAG_DROP = 1 , GNUNET_PQ_FLAG_CHECK_CURRENT = 2 }
	Flags to control PQ operation. More...

Functions
void	GNUNET_PQ_cleanup_query_params_closures (const struct GNUNET_PQ_QueryParam *params)
	Must be called to cleanup memory from closures after the query parameters have been used as much as needed. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_null (void)
	Generate query parameter to create a NULL value. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_fixed_size (const void *ptr, size_t ptr_size)
	Generate query parameter for a buffer ptr of ptr_size bytes. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_string (const char *ptr)
	Generate query parameter for a string. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_bool (bool b)
	Pass a boolean into a query. More...
enum GNUNET_GenericReturnValue	GNUNET_PQ_get_oid_by_name (struct GNUNET_PQ_Context *db, const char *name, Oid *oid)
	Returns the oid for a given datatype by name. More...
struct GNUNET_PQ_ArrayHeader_P	__attribute__ ((packed))
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_bool (unsigned int num, const bool *elements, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of bool in host byte order. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_uint16 (unsigned int num, const uint16_t *elements, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of uint16_t in host byte order. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_uint32 (unsigned int num, const uint32_t *elements, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of uint32_t in host byte order. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_uint64 (unsigned int num, const uint64_t *elements, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of uint64 in host byte order. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_bytes (unsigned int num, const void *elements, const size_t *sizes, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of buffers elements, each of corresponding size given in sizes. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_bytes_same_size (unsigned int num, const void *elements, size_t same_size, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of buffers elements, each of the same size size. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_ptrs_bytes_same_size (unsigned int num, const void *elements[static num], size_t same_size, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of pointers to buffers elements, each of the same size size. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_string (unsigned int num, const char *elements, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of strings (continuous) More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_ptrs_string (unsigned int num, const char *elements[static num], struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of strings (pointers) More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_abs_time (unsigned int num, const struct GNUNET_TIME_Absolute *elements, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of absolute time stamps (continuous) More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_ptrs_abs_time (unsigned int num, const struct GNUNET_TIME_Absolute *elements[], struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of absolute time stamps (pointers) More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_rel_time (unsigned int num, const struct GNUNET_TIME_Relative *elements, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of relative time stamps (continuous) More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_ptrs_rel_time (unsigned int num, const struct GNUNET_TIME_Relative *elements[], struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of relative time stamps (pointers) More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_timestamp (unsigned int num, const struct GNUNET_TIME_Timestamp *elements, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of time stamps (continuous) More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_ptrs_timestamp (unsigned int num, const struct GNUNET_TIME_Timestamp *elements[], struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of time stamps (pointers) More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_rsa_public_key (const struct GNUNET_CRYPTO_RsaPublicKey *x)
	Generate query parameter for an RSA public key. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_rsa_signature (const struct GNUNET_CRYPTO_RsaSignature *x)
	Generate query parameter for an RSA signature. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_relative_time (const struct GNUNET_TIME_Relative *x)
	Generate query parameter for a relative time value. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_absolute_time (const struct GNUNET_TIME_Absolute *x)
	Generate query parameter for an absolute time value. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_timestamp (const struct GNUNET_TIME_Timestamp *x)
	Generate query parameter for a timestamp. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_absolute_time_nbo (const struct GNUNET_TIME_AbsoluteNBO *x)
	Generate query parameter for an absolute time value. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_timestamp_nbo (const struct GNUNET_TIME_TimestampNBO *x)
	Generate query parameter for a timestamp in NBO. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_uint16 (const uint16_t *x)
	Generate query parameter for an uint16_t in host byte order. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_uint32 (const uint32_t *x)
	Generate query parameter for an uint32_t in host byte order. More...
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_uint64 (const uint64_t *x)
	Generate query parameter for an uint16_t in host byte order. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_allow_null (struct GNUNET_PQ_ResultSpec rs, bool *is_null)
	Allow NULL value to be found in the database for the given value. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_variable_size (const char *name, void **dst, size_t *sptr)
	Variable-size result expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_fixed_size (const char *name, void *dst, size_t dst_size)
	Fixed-size result expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_string (const char *name, char **dst)
	0-terminated string expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_bool (const char *name, bool *dst)
	boolean expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_rsa_public_key (const char *name, struct GNUNET_CRYPTO_RsaPublicKey **rsa)
	RSA public key expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_rsa_signature (const char *name, struct GNUNET_CRYPTO_RsaSignature **sig)
	RSA signature expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_absolute_time (const char *name, struct GNUNET_TIME_Absolute *at)
	Absolute time expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_timestamp (const char *name, struct GNUNET_TIME_Timestamp *t)
	Timestamp expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_relative_time (const char *name, struct GNUNET_TIME_Relative *rt)
	Relative time expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_absolute_time_nbo (const char *name, struct GNUNET_TIME_AbsoluteNBO *at)
	Absolute time expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_timestamp_nbo (const char *name, struct GNUNET_TIME_TimestampNBO *tn)
	Timestamp expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_uint16 (const char *name, uint16_t *u16)
	uint16_t expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_uint32 (const char *name, uint32_t *u32)
	uint32_t expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_uint64 (const char *name, uint64_t *u64)
	uint64_t expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_array_bool (struct GNUNET_PQ_Context *db, const char *name, size_t *num, bool **bools)
	array of bool expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_array_uint16 (struct GNUNET_PQ_Context *db, const char *name, size_t *num, uint16_t **dst)
	array of uint16_t expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_array_uint32 (struct GNUNET_PQ_Context *db, const char *name, size_t *num, uint32_t **dst)
	array of uint32_t expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_array_uint64 (struct GNUNET_PQ_Context *db, const char *name, size_t *num, uint64_t **dst)
	array of uint64_t expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_array_abs_time (struct GNUNET_PQ_Context *db, const char *name, size_t *num, struct GNUNET_TIME_Absolute **dst)
	array of absolute time expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_array_rel_time (struct GNUNET_PQ_Context *db, const char *name, size_t *num, struct GNUNET_TIME_Relative **dst)
	array of relative time expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_array_timestamp (struct GNUNET_PQ_Context *db, const char *name, size_t *num, struct GNUNET_TIME_Timestamp **dst)
	array of relative time expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_array_variable_size (struct GNUNET_PQ_Context *db, const char *name, size_t *num, size_t **sizes, void **dst)
	Array of variable-size result expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_array_fixed_size (struct GNUNET_PQ_Context *db, const char *name, size_t size, size_t *num, void **dst)
	Array of fixed-size result expected. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_array_string (struct GNUNET_PQ_Context *db, const char *name, size_t *num, char **dst)
	Array of 0-terminated strings expected. More...
PGresult *	GNUNET_PQ_exec_prepared (struct GNUNET_PQ_Context *db, const char *name, const struct GNUNET_PQ_QueryParam *params)
	Execute a prepared statement. More...
enum GNUNET_GenericReturnValue	GNUNET_PQ_extract_result (PGresult *result, struct GNUNET_PQ_ResultSpec *rs, int row)
	Extract results from a query result according to the given specification. More...
void	GNUNET_PQ_cleanup_result (struct GNUNET_PQ_ResultSpec *rs)
	Free all memory that was allocated in rs during GNUNET_PQ_extract_result(). More...
enum GNUNET_DB_QueryStatus	GNUNET_PQ_eval_result (struct GNUNET_PQ_Context *db, const char *statement_name, PGresult *result)
	Check the result's error code to see what happened. More...
enum GNUNET_DB_QueryStatus	GNUNET_PQ_eval_prepared_non_select (struct GNUNET_PQ_Context *db, const char *statement_name, const struct GNUNET_PQ_QueryParam *params)
	Execute a named prepared statement that is NOT a SELECT statement in connection using the given params. More...
enum GNUNET_DB_QueryStatus	GNUNET_PQ_eval_prepared_multi_select (struct GNUNET_PQ_Context *db, const char *statement_name, const struct GNUNET_PQ_QueryParam *params, GNUNET_PQ_PostgresResultHandler rh, void *rh_cls)
	Execute a named prepared statement that is a SELECT statement which may return multiple results in connection using the given params. More...
enum GNUNET_DB_QueryStatus	GNUNET_PQ_eval_prepared_singleton_select (struct GNUNET_PQ_Context *db, const char *statement_name, const struct GNUNET_PQ_QueryParam *params, struct GNUNET_PQ_ResultSpec *rs)
	Execute a named prepared statement that is a SELECT statement which must return a single result in connection using the given params. More...
struct GNUNET_PQ_PreparedStatement	GNUNET_PQ_make_prepare (const char *name, const char *sql)
	Create a struct GNUNET_PQ_PreparedStatement. More...
enum GNUNET_GenericReturnValue	GNUNET_PQ_prepare_statements (struct GNUNET_PQ_Context *db, const struct GNUNET_PQ_PreparedStatement *ps)
	Request creation of prepared statements ps from Postgres. More...
enum GNUNET_GenericReturnValue	GNUNET_PQ_prepare_once (struct GNUNET_PQ_Context *db, const struct GNUNET_PQ_PreparedStatement *ps)
	Request creation of prepared statements ps from Postgres, but do not automatically re-prepare the statement if we are disconnected from the database. More...
struct GNUNET_PQ_ExecuteStatement	GNUNET_PQ_make_execute (const char *sql)
	Create a struct GNUNET_PQ_ExecuteStatement where errors are fatal. More...
struct GNUNET_PQ_ExecuteStatement	GNUNET_PQ_make_try_execute (const char *sql)
	Create a struct GNUNET_PQ_ExecuteStatement where errors should be tolerated. More...
enum GNUNET_GenericReturnValue	GNUNET_PQ_exec_statements (struct GNUNET_PQ_Context *db, const struct GNUNET_PQ_ExecuteStatement *es)
	Request execution of an array of statements es from Postgres. More...
struct GNUNET_PQ_Context *	GNUNET_PQ_connect (const char *config_str, const char *load_path, const struct GNUNET_PQ_ExecuteStatement *es, const struct GNUNET_PQ_PreparedStatement *ps)
	Create a connection to the Postgres database using config_str for the configuration. More...
enum GNUNET_GenericReturnValue	GNUNET_PQ_exec_sql (struct GNUNET_PQ_Context *db, const char *buf)
	Execute SQL statements from buf against db. More...
struct GNUNET_PQ_Context *	GNUNET_PQ_connect2 (const char *config_str, const char *load_path, const char *auto_suffix, const struct GNUNET_PQ_ExecuteStatement *es, const struct GNUNET_PQ_PreparedStatement *ps, enum GNUNET_PQ_Options flags)
	Create a connection to the Postgres database using config_str for the configuration. More...
struct GNUNET_PQ_Context *	GNUNET_PQ_connect_with_cfg (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *load_path_suffix, const struct GNUNET_PQ_ExecuteStatement *es, const struct GNUNET_PQ_PreparedStatement *ps)
	Connect to a postgres database using the configuration option "CONFIG" in section. More...
struct GNUNET_PQ_Context *	GNUNET_PQ_connect_with_cfg2 (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *load_path_suffix, const struct GNUNET_PQ_ExecuteStatement *es, const struct GNUNET_PQ_PreparedStatement *ps, enum GNUNET_PQ_Options flags)
	Connect to a postgres database using the configuration option "CONFIG" in section. More...
void	GNUNET_PQ_reconnect_if_down (struct GNUNET_PQ_Context *db)
	Reinitialize the database db if the connection is down. More...
void	GNUNET_PQ_reconnect (struct GNUNET_PQ_Context *db)
	Reinitialize the database db. More...
struct GNUNET_DB_EventHandler *	GNUNET_PQ_event_listen (struct GNUNET_PQ_Context *db, const struct GNUNET_DB_EventHeaderP *es, struct GNUNET_TIME_Relative timeout, GNUNET_DB_EventCallback cb, void *cb_cls)
	Register callback to be invoked on events of type es. More...
void	GNUNET_PQ_event_listen_cancel (struct GNUNET_DB_EventHandler *eh)
	Stop notifications. More...
void	GNUNET_PQ_event_do_poll (struct GNUNET_PQ_Context *db)
	Poll for events right now. More...
void	GNUNET_PQ_event_notify (struct GNUNET_PQ_Context *db, const struct GNUNET_DB_EventHeaderP *es, const void *extra, size_t extra_size)
	Notify all that listen on es of an event. More...
char *	GNUNET_PG_get_event_notify_channel (const struct GNUNET_DB_EventHeaderP *es)
	Compute the channel that one should notify upon for the given event specification. More...
enum GNUNET_GenericReturnValue	GNUNET_PQ_run_sql (struct GNUNET_PQ_Context *db, const char *load_path)
	Within the db context, run all the SQL files from the load_path from 0000-9999.sql (as long as the files exist contiguously). More...
void	GNUNET_PQ_disconnect (struct GNUNET_PQ_Context *db)
	Disconnect from the database, destroying the prepared statements and releasing other associated resources. More...

Variables
uint32_t	ndim
uint32_t	has_null
uint32_t	oid
uint32_t	dim
uint32_t	lbound
struct GNUNET_PQ_ResultSpec	__attribute__

Detailed Description

helper functions for Postgres DB interactions

Author

Christian Grothoff

Definition in file gnunet_pq_lib.h.

Macro Definition Documentation

GNUNET_PQ_query_param_end

#define GNUNET_PQ_query_param_end

Value:

  {                               \
    .conv = NULL,                 \
    .conv_cls = NULL,             \
    .data = NULL,                 \
    .size = 0,                    \
    .num_params = 0               \
  }

End of query parameter specification.

Definition at line 134 of file gnunet_pq_lib.h.

GNUNET_PQ_query_param_array_auto_from_type

#define GNUNET_PQ_query_param_array_auto_from_type	(		num,
			elements,
			db
	)

Value:

  GNUNET_PQ_query_param_array_bytes_same_size ((num), \
                                               (elements), \
                                               sizeof(*(elements)), \
                                               (db))

Generate array of equal-sized query parameter with size determined by variable type from a pointer to an continuous array.

Parameters

num	Number of elements in elements
elements	Continuous array of the query parameter to pass.
db	Database context, needed for database-depending encoding of elements

Returns

query parameter to use

Definition at line 319 of file gnunet_pq_lib.h.

GNUNET_PQ_query_param_array_ptrs_auto_from_type

#define GNUNET_PQ_query_param_array_ptrs_auto_from_type	(		num,
			elements,
			db
	)

Value:

  GNUNET_PQ_query_param_array_ptrs_bytes_same_size ((num), \
                                                    (const void **) (elements), \
                                                    sizeof(*(elements[0])), \
                                                    (db))

Generate array of equal-sized query parameter with size determined by variable type from a pointer to an array of pointers to objects of the same type.

Parameters

num	Number of elements in elements
elements	Continuous array of the query parameter to pass.
db	Database context, needed for database-depending encoding of elements

Returns

query parameter to use

Definition at line 352 of file gnunet_pq_lib.h.

GNUNET_PQ_query_param_auto_from_type

#define GNUNET_PQ_query_param_auto_from_type

(

x

)

GNUNET_PQ_query_param_fixed_size ((x), sizeof(*(x)))

Generate fixed-size query parameter with size determined by variable type.

Parameters

x	pointer to the query parameter to pass.

Returns

query parameter to use

Definition at line 396 of file gnunet_pq_lib.h.

GNUNET_PQ_result_spec_end

#define GNUNET_PQ_result_spec_end

Value:

  {                                       \
    .conv = NULL,                         \
    .cleaner = NULL,                      \
    .cls = NULL,                          \
    .dst = NULL,                          \
    .dst_size = 0,                        \
    .fname = NULL,                        \
    .result_size = NULL,                  \
    .is_nullable = false,                 \
    .is_null = NULL                       \
  }

End of result parameter specification.

Returns

array last entry for the result specification to use

Definition at line 687 of file gnunet_pq_lib.h.

GNUNET_PQ_result_spec_auto_from_type

#define GNUNET_PQ_result_spec_auto_from_type	(		name,
			dst
	)		GNUNET_PQ_result_spec_fixed_size (name, (dst), sizeof(*(dst)))

We expect a fixed-size result, with size determined by the type of * dst

Parameters

name	name of the field in the table
dst	point to where to store the result, type fits expected result size

Returns

array entry for the result specification to use

Definition at line 750 of file gnunet_pq_lib.h.

GNUNET_PQ_result_spec_auto_array_from_type

#define GNUNET_PQ_result_spec_auto_array_from_type	(		db,
			name,
			num,
			dst
	)

Value:

  GNUNET_PQ_result_spec_array_fixed_size ( \
    (db), \
    (name), \
    sizeof(*(dst)), \
    (num), \
    (void *) &(dst))

We expect a fixed-size result, with size determined by the type of * dst

Parameters

db	Database context, needed for OID lookup for the correct type
name	name of the field in the table
num	pointer to where to store the number of elements
dst	pointer to where to store the results, type fits expected result size

Returns

array entry for the result specification to use

Definition at line 1058 of file gnunet_pq_lib.h.

GNUNET_PQ_PREPARED_STATEMENT_END

#define GNUNET_PQ_PREPARED_STATEMENT_END

Value:

  {                                      \
    NULL, NULL                           \
  }

Terminator for prepared statement list.

Definition at line 1255 of file gnunet_pq_lib.h.

GNUNET_PQ_EXECUTE_STATEMENT_END

#define GNUNET_PQ_EXECUTE_STATEMENT_END

Value:

  {                                     \
    NULL, GNUNET_SYSERR                 \
  }

Terminator for executable statement list.

Definition at line 1327 of file gnunet_pq_lib.h.

Typedef Documentation

GNUNET_PQ_QueryConverter

typedef int(* GNUNET_PQ_QueryConverter) (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)

Function called to convert input argument into SQL parameters.

Parameters

	cls	closure
	data	pointer to input argument
	data_len	number of bytes in data (if applicable)
[out]	param_values	SQL data to set
[out]	param_lengths	SQL length data to set
[out]	param_formats	SQL format data to set
	param_length	number of entries available in the param_values, param_lengths and param_formats arrays
[out]	scratch	buffer for dynamic allocations (to be done via GNUNET_malloc()
	scratch_length	number of entries left in scratch

Returns

-1 on error, number of offsets used in scratch otherwise

Definition at line 59 of file gnunet_pq_lib.h.

GNUNET_PQ_QueryConverter_Cleanup

typedef void(* GNUNET_PQ_QueryConverter_Cleanup) (void *cls)

Function called to cleanup the closure of SQL parameters converter.

Will be called with GNUNET_PQ_query_params_cleanup

Parameters

cls

closure

Definition at line 76 of file gnunet_pq_lib.h.

GNUNET_PQ_ResultConverter

typedef enum GNUNET_GenericReturnValue(* GNUNET_PQ_ResultConverter) (void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)

Extract data from a Postgres database result at row row.

Parameters

	cls	closure
	result	where to extract data from
	int	row to extract data from
	fname	name (or prefix) of the fields to extract from
[in,out]	dst_size	where to store size of result, may be NULL
[out]	dst	where to store the result

Returns

GNUNET_YES if all results could be extracted GNUNET_NO if the field was NULL GNUNET_SYSERR if a result was invalid (non-existing field)

Definition at line 128 of file gnunet_pq_lib.h.

GNUNET_PQ_ResultCleanup

typedef void(* GNUNET_PQ_ResultCleanup) (void *cls, void *rd)

Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.

Parameters

cls	closure
rd	result data to clean up

Definition at line 621 of file gnunet_pq_lib.h.

GNUNET_PQ_PostgresResultHandler

typedef void(* GNUNET_PQ_PostgresResultHandler) (void *cls, PGresult *result, unsigned int num_results)

Function to be called with the results of a SELECT statement that has returned num_results results.

Parameters

cls	closure
result	the postgres result
num_result	the number of results in result

Definition at line 1178 of file gnunet_pq_lib.h.

Enumeration Type Documentation

GNUNET_PQ_Options

enum GNUNET_PQ_Options

Flags to control PQ operation.

Enumerator
GNUNET_PQ_FLAG_NONE	Traditional default. Do nothing special.
GNUNET_PQ_FLAG_DROP	Dropping database. Do not attempt to initialize versioning schema if not present.
GNUNET_PQ_FLAG_CHECK_CURRENT	Check database version is current. Fail to connect if it is not.

Definition at line 1374 of file gnunet_pq_lib.h.

{
  GNUNET_PQ_FLAG_NONE = 0,
 
  GNUNET_PQ_FLAG_DROP = 1,
 
  GNUNET_PQ_FLAG_CHECK_CURRENT = 2
};

Function Documentation

GNUNET_PQ_cleanup_query_params_closures()

void GNUNET_PQ_cleanup_query_params_closures

(

const struct GNUNET_PQ_QueryParam *

params

)

Must be called to cleanup memory from closures after the query parameters have been used as much as needed.

Parameters

params

Array of GNUNET_PQ_QueryParam which must terminate with a GNUNET_PQ_query_param_end

Definition at line 123 of file pq.c.

{
  for (unsigned int i = 0; 0 != params[i].num_params; i++)
  {
    const struct GNUNET_PQ_QueryParam *x = &params[i];
 
    if ((NULL != x->conv_cls) &&
        (NULL != x->conv_cls_cleanup))
      x->conv_cls_cleanup (x->conv_cls);
  }
 
}

References GNUNET_PQ_QueryParam::conv_cls, GNUNET_PQ_QueryParam::conv_cls_cleanup, and GNUNET_PQ_QueryParam::num_params.

GNUNET_PQ_query_param_null()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_null

(

void

)

Generate query parameter to create a NULL value.

Returns

query parameter to use to insert NULL into DB

Definition at line 47 of file pq_query_helper.c.

{
  struct GNUNET_PQ_QueryParam res = {
    .conv = &qconv_null,
    .num_params = 1
  };
 
  return res;
}

References data, and GNUNET_break.

Referenced by postgres_plugin_put().

Here is the caller graph for this function:

GNUNET_PQ_query_param_fixed_size()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_fixed_size	(	const void *	ptr,
		size_t	ptr_size
	)

Generate query parameter for a buffer ptr of ptr_size bytes.

Parameters

ptr	pointer to the query parameter to pass
ptr_size	number of bytes in ptr

Returns

query parameter to use

Definition at line 98 of file pq_query_helper.c.

{
  struct GNUNET_PQ_QueryParam res = {
    .conv = &qconv_fixed,
    .conv_cls = NULL,
    .data = ptr,
    .size = ptr_size,
    .num_params = 1
  };
 
  return res;
}

Referenced by postgres_plugin_put(), and postgres_plugin_remove_key().

Here is the caller graph for this function:

GNUNET_PQ_query_param_string()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_string

(

const char *

ptr

)

Generate query parameter for a string.

Parameters

ptr	pointer to the string query parameter to pass

Returns

query parameter to use

Definition at line 98 of file pq_query_helper.c.

{
  return GNUNET_PQ_query_param_fixed_size (ptr,
                                           strlen (ptr));
}

GNUNET_PQ_query_param_bool()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_bool

(

bool

b

)

Pass a boolean into a query.

Parameters

b	boolean bit to pass

Returns

query parameter to use

Definition at line 98 of file pq_query_helper.c.

{
  static uint8_t bt = 1;
  static uint8_t bf = 0;
 
  return GNUNET_PQ_query_param_fixed_size (b ? &bt : &bf,
                                           sizeof (uint8_t));
}

References data, and GNUNET_break.

GNUNET_PQ_get_oid_by_name()

enum GNUNET_GenericReturnValue GNUNET_PQ_get_oid_by_name	(	struct GNUNET_PQ_Context *	db,
		const char *	name,
		Oid *	oid
	)

Returns the oid for a given datatype by name.

Parameters

	db	The db-connection
	name	The name of the datatype
[out]	oid	The OID of the datatype.

Returns

GNUNET_OK when the datatype was found, GNUNET_SYSERR otherwise

Definition at line 314 of file pq_connect.c.

{
  /* Check if the entry is in the cache already */
  for (unsigned int i = 0; i < db->oids.num; i++)
  {
    /* Pointer comparison */
    if (name == db->oids.table[i].name)
    {
      *oid = db->oids.table[i].oid;
      return GNUNET_OK;
    }
  }
 
  /* No entry found in cache, ask database */
  {
    enum GNUNET_DB_QueryStatus qs;
    struct GNUNET_PQ_QueryParam params[] = {
      GNUNET_PQ_query_param_string (name),
      GNUNET_PQ_query_param_end
    };
    struct GNUNET_PQ_ResultSpec spec[] = {
      GNUNET_PQ_result_spec_uint32 ("oid",
                                    oid),
      GNUNET_PQ_result_spec_end
    };
 
    GNUNET_assert (NULL != db);
 
    qs = GNUNET_PQ_eval_prepared_singleton_select (db,
                                                   "gnunet_pq_get_oid_by_name",
                                                   params,
                                                   spec);
    if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != qs)
      return GNUNET_SYSERR;
  }
 
  /* Add the entry to the cache */
  if (NULL == db->oids.table)
  {
    db->oids.table = GNUNET_new_array (8,
                                       typeof(*db->oids.table));
    db->oids.cap = 8;
    db->oids.num = 0;
  }
 
  if (db->oids.cap <= db->oids.num)
    GNUNET_array_grow (db->oids.table,
                       db->oids.cap,
                       db->oids.cap + 8);
 
  db->oids.table[db->oids.num].name = name;
  db->oids.table[db->oids.num].oid = *oid;
  db->oids.num++;
 
  return GNUNET_OK;
}

__attribute__()

struct GNUNET_PQ_ArrayHeader_P __attribute__

(

(packed)

)

GNUNET_PQ_query_param_array_bool()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_bool	(	unsigned int	num,
		const bool *	elements,
		struct GNUNET_PQ_Context *	db
	)

Generate query parameter for an array of bool in host byte order.

Parameters

num	Number of elements in elements
elements	Continuous array of num boolean elements
db	Database context, needed for database-depending encoding of elements

Returns

query parameter to use

Definition at line 648 of file pq_query_helper.c.

{
  Oid oid;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "bool",
                                            &oid));
  return query_param_array_generic (num,
                                    true,
                                    elements,
                                    NULL,
                                    sizeof(bool),
                                    array_of_bool,
                                    oid);
}

GNUNET_PQ_query_param_array_uint16()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_uint16	(	unsigned int	num,
		const uint16_t *	elements,
		struct GNUNET_PQ_Context *	db
	)

Generate query parameter for an array of uint16_t in host byte order.

Note that the (unsigend) elements are not checked to wrap over INT2_MAX

Parameters

num	Number of elements in elements
elements	Continuous array of num uint16 elements
db	Database context, needed for database-depending encoding of elements

Returns

query parameter to use

Definition at line 648 of file pq_query_helper.c.

{
  Oid oid;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "int2",
                                            &oid));
  return query_param_array_generic (num,
                                    true,
                                    elements,
                                    NULL,
                                    sizeof(uint16_t),
                                    array_of_uint16,
                                    oid);
}

GNUNET_PQ_query_param_array_uint32()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_uint32	(	unsigned int	num,
		const uint32_t *	elements,
		struct GNUNET_PQ_Context *	db
	)

Generate query parameter for an array of uint32_t in host byte order.

Note that the (unsigend) elements are not checked to wrap over INT4_MAX

Parameters

num	Number of elements in elements
elements	Continuous Array of num uint32_t elements
db	Database context, needed for database-depending encoding of elements

Returns

query parameter to use

Definition at line 648 of file pq_query_helper.c.

{
  Oid oid;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "int4",
                                            &oid));
  return query_param_array_generic (num,
                                    true,
                                    elements,
                                    NULL,
                                    sizeof(uint32_t),
                                    array_of_uint32,
                                    oid);
}

GNUNET_PQ_query_param_array_uint64()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_uint64	(	unsigned int	num,
		const uint64_t *	elements,
		struct GNUNET_PQ_Context *	db
	)

Generate query parameter for an array of uint64 in host byte order.

Note that the (unsigend) elements are not checked to wrap over INT8_MAX

Parameters

num	Number of elements in elements
elements	Continuous array of num uint64_t elements
db	Database context, needed for database-depending encoding of elements

Returns

query parameter to use

Definition at line 648 of file pq_query_helper.c.

{
  Oid oid;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "int8",
                                            &oid));
  return query_param_array_generic (num,
                                    true,
                                    elements,
                                    NULL,
                                    sizeof(uint64_t),
                                    array_of_uint64,
                                    oid);
}

GNUNET_PQ_query_param_array_bytes()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_bytes	(	unsigned int	num,
		const void *	elements,
		const size_t *	sizes,
		struct GNUNET_PQ_Context *	db
	)

Generate query parameter for an array of buffers elements, each of corresponding size given in sizes.

Parameters

num	Number of elements in elements
elements	Continous array of num buffers, each of corresponding size given in sizes.
sizes	Pointer to sizes in bytes of each element in elements
db	Database context, needed for database-depending encoding of elements

Returns

query parameter to use

Definition at line 648 of file pq_query_helper.c.

{
  Oid oid;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "bytea",
                                            &oid));
  return query_param_array_generic (num,
                                    true,
                                    elements,
                                    sizes,
                                    0,
                                    array_of_byte,
                                    oid);
}

GNUNET_PQ_query_param_array_bytes_same_size()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_bytes_same_size	(	unsigned int	num,
		const void *	elements,
		size_t	same_size,
		struct GNUNET_PQ_Context *	db
	)

Generate query parameter for an array of buffers elements, each of the same size size.

Parameters

num	Number of elements in elements
elements	Continous array of num buffers, each with the same size same_size
same_size	Size in bytes of each element in elements
db	Database context, needed for database-depending encoding of elements

Returns

query parameter to use

Definition at line 648 of file pq_query_helper.c.

{
  Oid oid;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "bytea",
                                            &oid));
  return query_param_array_generic (num,
                                    true,
                                    elements,
                                    NULL,
                                    same_size,
                                    array_of_byte,
                                    oid);
}

GNUNET_PQ_query_param_array_ptrs_bytes_same_size()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_ptrs_bytes_same_size	(	unsigned int	num,
		const void *	elements[static num],
		size_t	same_size,
		struct GNUNET_PQ_Context *	db
	)

Generate query parameter for an array of pointers to buffers elements, each of the same size size.

Parameters

num	Number of elements in elements
elements	Array of num pointers to buffers, each with the same size same_size
same_size	Size in bytes of each element in elements
db	Database context, needed for database-depending encoding of elements

Returns

query parameter to use

Definition at line 648 of file pq_query_helper.c.

{
  Oid oid;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "bytea",
                                            &oid));
  return query_param_array_generic (num,
                                    false,
                                    elements,
                                    NULL,
                                    same_size,
                                    array_of_byte,
                                    oid);
}

GNUNET_PQ_query_param_array_string()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_string	(	unsigned int	num,
		const char *	elements,
		struct GNUNET_PQ_Context *	db
	)

Generate query parameter for an array of strings (continuous)

Parameters

num	Number of elements in elements
elements	Array of num continuous strings (zero-terminated each)
db	Database context, needed for database-depending encoding of elements

Returns

query parameter to use

Definition at line 648 of file pq_query_helper.c.

{
  Oid oid;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "text",
                                            &oid));
  return query_param_array_generic (num,
                                    true,
                                    elements,
                                    NULL,
                                    0,
                                    array_of_string,
                                    oid);
}

GNUNET_PQ_query_param_array_ptrs_string()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_ptrs_string	(	unsigned int	num,
		const char *	elements[static num],
		struct GNUNET_PQ_Context *	db
	)

Generate query parameter for an array of strings (pointers)

Parameters

num	Number of elements in elements
elements	Array of num pointer to strings
db	Database context, needed for database-depending encoding of elements

Returns

query parameter to use

Definition at line 648 of file pq_query_helper.c.

{
  Oid oid;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "text",
                                            &oid));
  return query_param_array_generic (num,
                                    false,
                                    elements,
                                    NULL,
                                    0,
                                    array_of_string,
                                    oid);
}

GNUNET_PQ_query_param_array_abs_time()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_abs_time	(	unsigned int	num,
		const struct GNUNET_TIME_Absolute *	elements,
		struct GNUNET_PQ_Context *	db
	)

Generate query parameter for an array of absolute time stamps (continuous)

Parameters

num	Number of elements in elements
elements	Array of num absolute timestamps

Returns

query parameter to use

Definition at line 648 of file pq_query_helper.c.

{
  Oid oid;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "int8",
                                            &oid));
  return query_param_array_generic (num,
                                    true,
                                    elements,
                                    NULL,
                                    sizeof(struct GNUNET_TIME_Absolute),
                                    array_of_abs_time,
                                    oid);
}

References GNUNET_TIME_Timestamp::abs_time, GNUNET_TIME_Absolute::abs_value_us, array_of_abs_time, array_of_bool, array_of_byte, array_of_rel_time, array_of_string, array_of_timestamp, array_of_uint16, array_of_uint32, array_of_uint64, data, GNUNET_assert, GNUNET_free, GNUNET_htonll(), GNUNET_malloc, GNUNET_memcpy, GNUNET_new_array, h, INT_MAX, len, meta, GNUNET_TIME_Relative::rel_value_us, RETURN_UNLESS, and qconv_array_cls::sizes.

Here is the call graph for this function:

GNUNET_PQ_query_param_array_ptrs_abs_time()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_ptrs_abs_time	(	unsigned int	num,
		const struct GNUNET_TIME_Absolute *	elements[],
		struct GNUNET_PQ_Context *	db
	)

Generate query parameter for an array of absolute time stamps (pointers)

Parameters

num	Number of elements in elements
elements	Array of num pointers to absolute timestamps

Returns

query parameter to use

Definition at line 648 of file pq_query_helper.c.

{
  Oid oid;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "int8",
                                            &oid));
  return query_param_array_generic (num,
                                    false,
                                    elements,
                                    NULL,
                                    sizeof(struct GNUNET_TIME_Absolute),
                                    array_of_abs_time,
                                    oid);
}

GNUNET_PQ_query_param_array_rel_time()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_rel_time	(	unsigned int	num,
		const struct GNUNET_TIME_Relative *	elements,
		struct GNUNET_PQ_Context *	db
	)

Generate query parameter for an array of relative time stamps (continuous)

Parameters

num	Number of elements in elements
elements	Array of num relative timestamps

Returns

query parameter to use

Definition at line 648 of file pq_query_helper.c.

{
  Oid oid;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "int8",
                                            &oid));
  return query_param_array_generic (num,
                                    true,
                                    elements,
                                    NULL,
                                    sizeof(struct GNUNET_TIME_Relative),
                                    array_of_abs_time,
                                    oid);
}

GNUNET_PQ_query_param_array_ptrs_rel_time()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_ptrs_rel_time	(	unsigned int	num,
		const struct GNUNET_TIME_Relative *	elements[],
		struct GNUNET_PQ_Context *	db
	)

Generate query parameter for an array of relative time stamps (pointers)

Parameters

num	Number of elements in elements
elements	Array of num pointers to relative timestamps

Returns

query parameter to use

Definition at line 648 of file pq_query_helper.c.

{
  Oid oid;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "int8",
                                            &oid));
  return query_param_array_generic (num,
                                    false,
                                    elements,
                                    NULL,
                                    sizeof(struct GNUNET_TIME_Relative),
                                    array_of_abs_time,
                                    oid);
}

GNUNET_PQ_query_param_array_timestamp()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_timestamp	(	unsigned int	num,
		const struct GNUNET_TIME_Timestamp *	elements,
		struct GNUNET_PQ_Context *	db
	)

Generate query parameter for an array of time stamps (continuous)

Parameters

num	Number of elements in elements
elements	Array of num timestamps

Returns

query parameter to use

Definition at line 648 of file pq_query_helper.c.

{
  Oid oid;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "int8",
                                            &oid));
  return query_param_array_generic (num,
                                    true,
                                    elements,
                                    NULL,
                                    sizeof(struct GNUNET_TIME_Timestamp),
                                    array_of_timestamp,
                                    oid);
}

GNUNET_PQ_query_param_array_ptrs_timestamp()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_ptrs_timestamp	(	unsigned int	num,
		const struct GNUNET_TIME_Timestamp *	elements[],
		struct GNUNET_PQ_Context *	db
	)

Generate query parameter for an array of time stamps (pointers)

Parameters

num	Number of elements in elements
elements	Array of num pointers to relative timestamps

Returns

query parameter to use

Definition at line 648 of file pq_query_helper.c.

{
  Oid oid;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "int8",
                                            &oid));
  return query_param_array_generic (num,
                                    false,
                                    elements,
                                    NULL,
                                    sizeof(struct GNUNET_TIME_Timestamp),
                                    array_of_timestamp,
                                    oid);
}

GNUNET_PQ_query_param_rsa_public_key()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_rsa_public_key

(

const struct GNUNET_CRYPTO_RsaPublicKey *

x

)

Generate query parameter for an RSA public key.

The database must contain a BLOB type in the respective position.

Parameters

x	the query parameter to pass.

Returns

query parameter to use

Definition at line 341 of file pq_query_helper.c.

{
  struct GNUNET_PQ_QueryParam res = {
    .conv = &qconv_rsa_public_key,
    .data = x,
    .num_params = 1
  };
 
  return res;
}

References buf, data, GNUNET_break, and GNUNET_CRYPTO_rsa_public_key_encode().

Here is the call graph for this function:

GNUNET_PQ_query_param_rsa_signature()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_rsa_signature

(

const struct GNUNET_CRYPTO_RsaSignature *

x

)

Generate query parameter for an RSA signature.

The database must contain a BLOB type in the respective position.

Parameters

x	the query parameter to pass

Returns

query parameter to use

Definition at line 397 of file pq_query_helper.c.

{
  struct GNUNET_PQ_QueryParam res = {
    .conv = &qconv_rsa_signature,
    .data = x,
    .num_params = 1
  };
 
  return res;
}

References buf, data, GNUNET_break, and GNUNET_CRYPTO_rsa_signature_encode().

Here is the call graph for this function:

GNUNET_PQ_query_param_relative_time()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_relative_time

(

const struct GNUNET_TIME_Relative *

x

)

Generate query parameter for a relative time value.

The database must store a 64-bit integer.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 452 of file pq_query_helper.c.

{
  struct GNUNET_PQ_QueryParam res = {
    .conv = &qconv_rel_time,
    .data = x,
    .size = sizeof(*x),
    .num_params = 1
  };
 
  return res;
}

References data, GNUNET_break, GNUNET_htonll(), GNUNET_new, and GNUNET_TIME_Relative::rel_value_us.

Here is the call graph for this function:

GNUNET_PQ_query_param_absolute_time()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_absolute_time

(

const struct GNUNET_TIME_Absolute *

x

)

Generate query parameter for an absolute time value.

The database must store a 64-bit integer.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 511 of file pq_query_helper.c.

{
  struct GNUNET_PQ_QueryParam res = {
    .conv = &qconv_abs_time,
    .data = x,
    .size = sizeof(*x),
    .num_params = 1
  };
 
  return res;
}

References GNUNET_TIME_Absolute::abs_value_us, data, GNUNET_break, GNUNET_htonll(), and GNUNET_new.

Referenced by delete_old_block(), namecache_postgres_expire_blocks(), postgres_plugin_del(), postgres_plugin_get_closest(), postgres_plugin_get_expiration(), and postgres_plugin_put().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_query_param_timestamp()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_timestamp

(

const struct GNUNET_TIME_Timestamp *

x

)

Generate query parameter for a timestamp.

The database must store a 64-bit integer.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 511 of file pq_query_helper.c.

{
  return GNUNET_PQ_query_param_absolute_time (&x->abs_time);
}

GNUNET_PQ_query_param_absolute_time_nbo()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_absolute_time_nbo

(

const struct GNUNET_TIME_AbsoluteNBO *

x

)

Generate query parameter for an absolute time value.

The database must store a 64-bit integer.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 511 of file pq_query_helper.c.

{
  return GNUNET_PQ_query_param_auto_from_type (&x->abs_value_us__);
}

GNUNET_PQ_query_param_timestamp_nbo()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_timestamp_nbo

(

const struct GNUNET_TIME_TimestampNBO *

x

)

Generate query parameter for a timestamp in NBO.

The database must store a 64-bit integer.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 511 of file pq_query_helper.c.

{
  return GNUNET_PQ_query_param_absolute_time_nbo (&x->abs_time_nbo);
}

GNUNET_PQ_query_param_uint16()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_uint16

(

const uint16_t *

x

)

Generate query parameter for an uint16_t in host byte order.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 170 of file pq_query_helper.c.

{
  struct GNUNET_PQ_QueryParam res = {
    .conv = &qconv_uint16,
    .data = x,
    .size = sizeof(*x),
    .num_params = 1
  };
 
  return res;
}

References data, GNUNET_break, and GNUNET_new.

Referenced by postgres_plugin_get_key().

Here is the caller graph for this function:

GNUNET_PQ_query_param_uint32()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_uint32

(

const uint32_t *

x

)

Generate query parameter for an uint32_t in host byte order.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 227 of file pq_query_helper.c.

{
  struct GNUNET_PQ_QueryParam res = {
    .conv = &qconv_uint32,
    .data = x,
    .size = sizeof(*x),
    .num_params = 1
  };
 
  return res;
}

References data, GNUNET_break, and GNUNET_new.

Referenced by postgres_plugin_del(), postgres_plugin_get_closest(), postgres_plugin_get_key(), postgres_plugin_get_zero_anonymity(), and postgres_plugin_put().

Here is the caller graph for this function:

GNUNET_PQ_query_param_uint64()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_uint64

(

const uint64_t *

x

)

Generate query parameter for an uint16_t in host byte order.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 284 of file pq_query_helper.c.

{
  struct GNUNET_PQ_QueryParam res = {
    .conv = &qconv_uint64,
    .data = x,
    .size = sizeof(*x),
    .num_params = 1
  };
 
  return res;
}

References data, GNUNET_break, GNUNET_htonll(), and GNUNET_new.

Referenced by postgres_plugin_get_key(), postgres_plugin_get_zero_anonymity(), postgres_plugin_put(), process_result(), and repl_proc().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_result_spec_allow_null()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_allow_null	(	struct GNUNET_PQ_ResultSpec	rs,
		bool *	is_null
	)

Allow NULL value to be found in the database for the given value.

Parameters

	rs	result spec entry to modify
[out]	is_null	location set to 'true' if the value was indeed NULL, set to 'false' if the value was non-NULL

Returns

array entry for the result specification to use

Definition at line 1 of file pq_result_helper.c.

{
  struct GNUNET_PQ_ResultSpec rsr;
 
  rsr = rs;
  rsr.is_nullable = true;
  rsr.is_null = is_null;
  return rsr;
}

References GNUNET_PQ_ResultSpec::is_null, and GNUNET_PQ_ResultSpec::is_nullable.

Referenced by handle_results().

Here is the caller graph for this function:

GNUNET_PQ_result_spec_variable_size()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_variable_size	(	const char *	name,
		void **	dst,
		size_t *	sptr
	)

Variable-size result expected.

Parameters

	name	name of the field in the table
[out]	dst	where to store the result, allocated
[out]	sptr	where to store the size of dst

Returns

array entry for the result specification to use

Definition at line 55 of file pq_result_helper.c.

{
  struct GNUNET_PQ_ResultSpec res = {
    .conv = &extract_varsize_blob,
    .cleaner = &clean_varsize_blob,
    .dst = (void *) (dst),
    .fname = name,
    .result_size = sptr
  };
 
  return res;
}

Referenced by extract_result_cb(), handle_results(), lookup_records(), and process_result().

Here is the caller graph for this function:

GNUNET_PQ_result_spec_fixed_size()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_fixed_size	(	const char *	name,
		void *	dst,
		size_t	dst_size
	)

Fixed-size result expected.

Parameters

	name	name of the field in the table
[out]	dst	where to store the result
	dst_size	number of bytes in dst

Returns

array entry for the result specification to use

Definition at line 55 of file pq_result_helper.c.

{
  struct GNUNET_PQ_ResultSpec res = {
    .conv = &extract_fixed_blob,
    .dst = (dst),
    .dst_size = dst_size,
    .fname = name
  };
 
  return res;
}

GNUNET_PQ_result_spec_string()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_string	(	const char *	name,
		char **	dst
	)

0-terminated string expected.

Parameters

	name	name of the field in the table
[out]	dst	where to store the result, allocated

Returns

array entry for the result specification to use

Definition at line 485 of file pq_result_helper.c.

{
  struct GNUNET_PQ_ResultSpec res = {
    .conv = &extract_string,
    .cleaner = &clean_string,
    .dst = (void *) dst,
    .fname = (name)
  };
 
  return res;
}

Referenced by lookup_records().

Here is the caller graph for this function:

GNUNET_PQ_result_spec_bool()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_bool	(	const char *	name,
		bool *	dst
	)

boolean expected.

Parameters

	name	name of the field in the table
[out]	dst	where to store the result

Returns

array entry for the result specification to use

Definition at line 485 of file pq_result_helper.c.

{
  struct GNUNET_PQ_ResultSpec res = {
    .conv = &extract_bool,
    .dst = (void *) dst,
    .fname = name
  };
 
  return res;
}

GNUNET_PQ_result_spec_rsa_public_key()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_rsa_public_key	(	const char *	name,
		struct GNUNET_CRYPTO_RsaPublicKey **	rsa
	)

RSA public key expected.

Parameters

	name	name of the field in the table
[out]	rsa	where to store the result

Returns

array entry for the result specification to use

Definition at line 295 of file pq_result_helper.c.

{
  struct GNUNET_PQ_ResultSpec res = {
    .conv = &extract_rsa_public_key,
    .cleaner = &clean_rsa_public_key,
    .dst = (void *) rsa,
    .fname = name
  };
 
  return res;
}

GNUNET_PQ_result_spec_rsa_signature()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_rsa_signature	(	const char *	name,
		struct GNUNET_CRYPTO_RsaSignature **	sig
	)

RSA signature expected.

Parameters

	name	name of the field in the table
[out]	sig	where to store the result;

Returns

array entry for the result specification to use

Definition at line 390 of file pq_result_helper.c.

{
  struct GNUNET_PQ_ResultSpec res = {
    .conv = &extract_rsa_signature,
    .cleaner = &clean_rsa_signature,
    .dst = (void *) sig,
    .fname = name
  };
 
  return res;
}

GNUNET_PQ_result_spec_absolute_time()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_absolute_time	(	const char *	name,
		struct GNUNET_TIME_Absolute *	at
	)

Absolute time expected.

Parameters

	name	name of the field in the table
[out]	at	where to store the result

Returns

array entry for the result specification to use

Definition at line 485 of file pq_result_helper.c.

{
  struct GNUNET_PQ_ResultSpec res = {
    .conv = &extract_abs_time,
    .dst = (void *) at,
    .dst_size = sizeof(*at),
    .fname = name
  };
 
  return res;
}

Referenced by extract_result_cb(), handle_results(), and process_result().

Here is the caller graph for this function:

GNUNET_PQ_result_spec_timestamp()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_timestamp	(	const char *	name,
		struct GNUNET_TIME_Timestamp *	t
	)

Timestamp expected.

Parameters

	name	name of the field in the table
[out]	t	where to store the result

Returns

array entry for the result specification to use

Definition at line 485 of file pq_result_helper.c.

{
  struct GNUNET_PQ_ResultSpec res = {
    .conv = &extract_timestamp,
    .dst = (void *) at,
    .dst_size = sizeof(*at),
    .fname = name
  };
 
  return res;
}

GNUNET_PQ_result_spec_relative_time()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_relative_time	(	const char *	name,
		struct GNUNET_TIME_Relative *	rt
	)

Relative time expected.

Parameters

	name	name of the field in the table
[out]	rt	where to store the result

Returns

array entry for the result specification to use

Definition at line 485 of file pq_result_helper.c.

{
  struct GNUNET_PQ_ResultSpec res = {
    .conv = &extract_rel_time,
    .dst = (void *) rt,
    .dst_size = sizeof(*rt),
    .fname = name
  };
 
  return res;
}

GNUNET_PQ_result_spec_absolute_time_nbo()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_absolute_time_nbo	(	const char *	name,
		struct GNUNET_TIME_AbsoluteNBO *	at
	)

Absolute time expected.

Parameters

	name	name of the field in the table
[out]	at	where to store the result

Returns

array entry for the result specification to use

Definition at line 485 of file pq_result_helper.c.

{
  struct GNUNET_PQ_ResultSpec res =
    GNUNET_PQ_result_spec_auto_from_type (name,
                                          &at->abs_value_us__);
 
  return res;
}

GNUNET_PQ_result_spec_timestamp_nbo()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_timestamp_nbo	(	const char *	name,
		struct GNUNET_TIME_TimestampNBO *	tn
	)

Timestamp expected.

Parameters

	name	name of the field in the table
[out]	tn	where to store the result

Returns

array entry for the result specification to use

Definition at line 485 of file pq_result_helper.c.

{
  struct GNUNET_PQ_ResultSpec res = {
    .conv = &extract_timestamp_nbo,
    .dst = (void *) at,
    .dst_size = sizeof(*at),
    .fname = name
  };
 
  return res;
}

GNUNET_PQ_result_spec_uint16()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_uint16	(	const char *	name,
		uint16_t *	u16
	)

uint16_t expected.

Parameters

	name	name of the field in the table
[out]	u16	where to store the result

Returns

array entry for the result specification to use

Definition at line 485 of file pq_result_helper.c.

{
  struct GNUNET_PQ_ResultSpec res = {
    .conv = &extract_uint16,
    .dst = (void *) u16,
    .dst_size = sizeof(*u16),
    .fname = name
  };
 
  return res;
}

GNUNET_PQ_result_spec_uint32()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_uint32	(	const char *	name,
		uint32_t *	u32
	)

uint32_t expected.

Parameters

	name	name of the field in the table
[out]	u32	where to store the result

Returns

array entry for the result specification to use

Definition at line 485 of file pq_result_helper.c.

{
  struct GNUNET_PQ_ResultSpec res = {
    .conv = &extract_uint32,
    .dst = (void *) u32,
    .dst_size = sizeof(*u32),
    .fname = name
  };
 
  return res;
}

Referenced by extract_result_cb(), handle_results(), lookup_records(), and process_result().

Here is the caller graph for this function:

GNUNET_PQ_result_spec_uint64()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_uint64	(	const char *	name,
		uint64_t *	u64
	)

uint64_t expected.

Parameters

	name	name of the field in the table
[out]	u64	where to store the result

Returns

array entry for the result specification to use

Definition at line 485 of file pq_result_helper.c.

{
  struct GNUNET_PQ_ResultSpec res = {
    .conv = &extract_uint64,
    .dst = (void *) u64,
    .dst_size = sizeof(*u64),
    .fname = name
  };
 
  return res;
}

Referenced by lookup_records(), postgres_plugin_estimate_size(), and process_result().

Here is the caller graph for this function:

GNUNET_PQ_result_spec_array_bool()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_bool	(	struct GNUNET_PQ_Context *	db,
		const char *	name,
		size_t *	num,
		bool **	bools
	)

array of bool expected.

Parameters

	db	Database context, needed for OID lookup for the correct type
	name	name of the field in the table
[out]	num	where to store the number of elements in the array bools.
[out]	bools	pointer to where to store the result, an array of num bool's. Allocated by the function, MUST be freed with GNUNET_free.

Returns

array entry for the result specification to use

Definition at line 1412 of file pq_result_helper.c.

{
  struct array_result_cls *info =
    GNUNET_new (struct array_result_cls);
 
  info->num = num;
  info->typ = array_of_bool;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "bool",
                                            &info->oid));
 
  struct GNUNET_PQ_ResultSpec res = {
    .conv = extract_array_generic,
    .cleaner = array_cleanup,
    .dst = (void *) dst,
    .fname = name,
    .cls = info
  };
  return res;
}

GNUNET_PQ_result_spec_array_uint16()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_uint16	(	struct GNUNET_PQ_Context *	db,
		const char *	name,
		size_t *	num,
		uint16_t **	dst
	)

array of uint16_t expected.

Parameters

	db	Database context, needed for OID lookup for the correct type
	name	name of the field in the table
[out]	num	where to store the number of elements in the array u16s.
[out]	dst	pointer to where to store the an array of num uint16_t's. Allocated by the function, MUST be freed with GNUNET_free.

Returns

array entry for the result specification to use

Definition at line 1412 of file pq_result_helper.c.

{
  struct array_result_cls *info =
    GNUNET_new (struct array_result_cls);
 
  info->num = num;
  info->typ = array_of_uint16;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "int2",
                                            &info->oid));
 
  struct GNUNET_PQ_ResultSpec res = {
    .conv = extract_array_generic,
    .cleaner = array_cleanup,
    .dst = (void *) dst,
    .fname = name,
    .cls = info
  };
  return res;
}

GNUNET_PQ_result_spec_array_uint32()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_uint32	(	struct GNUNET_PQ_Context *	db,
		const char *	name,
		size_t *	num,
		uint32_t **	dst
	)

array of uint32_t expected.

Parameters

	db	Database context, needed for OID lookup for the correct type
	name	name of the field in the table
[out]	num	where to store the number of elements in the array u32s.
[out]	dst	pointer to where to store the array of num uint32_t's. Allocated by the function, MUST be freed with GNUNET_free.

Returns

array entry for the result specification to use

Definition at line 1412 of file pq_result_helper.c.

{
  struct array_result_cls *info =
    GNUNET_new (struct array_result_cls);
 
  info->num = num;
  info->typ = array_of_uint32;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "int4",
                                            &info->oid));
 
  struct GNUNET_PQ_ResultSpec res = {
    .conv = extract_array_generic,
    .cleaner = array_cleanup,
    .dst = (void *) dst,
    .fname = name,
    .cls = info
  };
  return res;
}

GNUNET_PQ_result_spec_array_uint64()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_uint64	(	struct GNUNET_PQ_Context *	db,
		const char *	name,
		size_t *	num,
		uint64_t **	dst
	)

array of uint64_t expected.

Parameters

	db	Database context, needed for OID lookup for the correct type
	name	name of the field in the table
[out]	num	where to store the number of elements in the array u64s.
[out]	dst	pointer to where to store the array of num uint64_t's. Allocated by the function, MUST be freed with GNUNET_free.

Returns

array entry for the result specification to use

Definition at line 1412 of file pq_result_helper.c.

{
  struct array_result_cls *info =
    GNUNET_new (struct array_result_cls);
 
  info->num = num;
  info->typ = array_of_uint64;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "int8",
                                            &info->oid));
 
  struct GNUNET_PQ_ResultSpec res = {
    .conv = extract_array_generic,
    .cleaner = array_cleanup,
    .dst = (void *) dst,
    .fname = name,
    .cls = info
  };
  return res;
}

GNUNET_PQ_result_spec_array_abs_time()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_abs_time	(	struct GNUNET_PQ_Context *	db,
		const char *	name,
		size_t *	num,
		struct GNUNET_TIME_Absolute **	dst
	)

array of absolute time expected.

Parameters

	db	Database context, needed for OID lookup for the correct type
	name	name of the field in the table
[out]	num	where to store the number of elements in the array u64s.
[out]	dst	pointer to where to store the array of num absolute time. Allocated by the function, MUST be freed with GNUNET_free.

Returns

array entry for the result specification to use

Definition at line 1412 of file pq_result_helper.c.

{
  struct array_result_cls *info =
    GNUNET_new (struct array_result_cls);
 
  info->num = num;
  info->typ = array_of_abs_time;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "int8",
                                            &info->oid));
 
  struct GNUNET_PQ_ResultSpec res = {
    .conv = extract_array_generic,
    .cleaner = array_cleanup,
    .dst = (void *) dst,
    .fname = name,
    .cls = info
  };
  return res;
}

GNUNET_PQ_result_spec_array_rel_time()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_rel_time	(	struct GNUNET_PQ_Context *	db,
		const char *	name,
		size_t *	num,
		struct GNUNET_TIME_Relative **	dst
	)

array of relative time expected.

Parameters

	db	Database context, needed for OID lookup for the correct type
	name	name of the field in the table
[out]	num	where to store the number of elements in the array u64s.
[out]	dst	pointer to where to store the array of num relate time. Allocated by the function, MUST be freed with GNUNET_free.

Returns

array entry for the result specification to use

Definition at line 1412 of file pq_result_helper.c.

{
  struct array_result_cls *info =
    GNUNET_new (struct array_result_cls);
 
  info->num = num;
  info->typ = array_of_rel_time;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "int8",
                                            &info->oid));
 
  struct GNUNET_PQ_ResultSpec res = {
    .conv = extract_array_generic,
    .cleaner = array_cleanup,
    .dst = (void *) dst,
    .fname = name,
    .cls = info
  };
  return res;
}

GNUNET_PQ_result_spec_array_timestamp()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_timestamp	(	struct GNUNET_PQ_Context *	db,
		const char *	name,
		size_t *	num,
		struct GNUNET_TIME_Timestamp **	dst
	)

array of relative time expected.

Parameters

	db	Database context, needed for OID lookup for the correct type
	name	name of the field in the table
[out]	num	where to store the number of elements in the array u64s.
[out]	dst	pointer to where to store the array of num timestamps. Allocated by the function, MUST be freed with GNUNET_free.

Returns

array entry for the result specification to use

Definition at line 1412 of file pq_result_helper.c.

{
  struct array_result_cls *info =
    GNUNET_new (struct array_result_cls);
 
  info->num = num;
  info->typ = array_of_timestamp;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "int8",
                                            &info->oid));
 
  struct GNUNET_PQ_ResultSpec res = {
    .conv = extract_array_generic,
    .cleaner = array_cleanup,
    .dst = (void *) dst,
    .fname = name,
    .cls = info
  };
  return res;
}

GNUNET_PQ_result_spec_array_variable_size()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_variable_size	(	struct GNUNET_PQ_Context *	db,
		const char *	name,
		size_t *	num,
		size_t **	sizes,
		void **	dst
	)

Array of variable-size result expected.

Parameters

	db	Database context, needed for OID lookup for the correct type
	name	name of the field in the table
[out]	num	where to store the number of elements
[out]	sizes	where to store the num size's of byte-buffers in dst
[out]	dst	where to store the continuous array of num byte-buffers , allocated

Returns

array entry for the result specification to use

Definition at line 1412 of file pq_result_helper.c.

{
  struct array_result_cls *info =
    GNUNET_new (struct array_result_cls);
 
  info->num = num;
  info->sizes = sizes;
  info->typ = array_of_byte;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "bytea",
                                            &info->oid));
 
  struct GNUNET_PQ_ResultSpec res = {
    .conv = extract_array_generic,
    .cleaner = array_cleanup,
    .dst = (void *) dst,
    .fname = name,
    .cls = info
  };
  return res;
}

GNUNET_PQ_result_spec_array_fixed_size()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_fixed_size	(	struct GNUNET_PQ_Context *	db,
		const char *	name,
		size_t	size,
		size_t *	num,
		void **	dst
	)

Array of fixed-size result expected.

Parameters

	db	Database context, needed for OID lookup for the correct type
	name	name of the field in the table
	size	number of bytes expected in each element of dst
[out]	num	where to store the number of elements
[out]	dst	where to store the results, an continuous array of fixed-size elements

Returns

array entry for the result specification to use

Definition at line 1412 of file pq_result_helper.c.

{
  struct array_result_cls *info =
    GNUNET_new (struct array_result_cls);
 
  info->num = num;
  info->same_size = size;
  info->typ = array_of_byte;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "bytea",
                                            &info->oid));
 
  struct GNUNET_PQ_ResultSpec res = {
    .conv = extract_array_generic,
    .cleaner = array_cleanup,
    .dst = (void *) dst,
    .fname = name,
    .cls = info
  };
  return res;
}

GNUNET_PQ_result_spec_array_string()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_string	(	struct GNUNET_PQ_Context *	db,
		const char *	name,
		size_t *	num,
		char **	dst
	)

Array of 0-terminated strings expected.

Parameters

	db	Database context, needed for OID lookup for the correct type
	name	name of the field in the table
[out]	num	where to store the number of elements
[out]	dst	where to store the allocated continous array of num 0-terminated strings

Returns

array entry for the result specification to use

Definition at line 1412 of file pq_result_helper.c.

{
  struct array_result_cls *info =
    GNUNET_new (struct array_result_cls);
 
  info->num = num;
  info->typ = array_of_string;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_PQ_get_oid_by_name (db,
                                            "text",
                                            &info->oid));
 
  struct GNUNET_PQ_ResultSpec res = {
    .conv = extract_array_generic,
    .cleaner = array_cleanup,
    .dst = (void *) dst,
    .fname = name,
    .cls = info
  };
  return res;
}

GNUNET_PQ_exec_prepared()

PGresult* GNUNET_PQ_exec_prepared	(	struct GNUNET_PQ_Context *	db,
		const char *	name,
		const struct GNUNET_PQ_QueryParam *	params
	)

Execute a prepared statement.

Parameters

db	database context
name	name of the prepared statement
params	parameters to the statement

Returns

postgres result

Deprecated:

(should become an internal API)

Definition at line 33 of file pq.c.

{
  unsigned int len;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Running prepared statement `%s' on %p\n",
              name,
              db);
  /* count the number of parameters */
  len = 0;
  for (unsigned int i = 0; 0 != params[i].num_params; i++)
    len += params[i].num_params;
 
  /* new scope to allow stack allocation without alloca */
  {
    /* Scratch buffer for temporary storage */
    void *scratch[GNUNET_NZL (len)];
    /* Parameter array we are building for the query */
    void *param_values[GNUNET_NZL (len)];
    int param_lengths[GNUNET_NZL (len)];
    int param_formats[GNUNET_NZL (len)];
    unsigned int off;
    /* How many entries in the scratch buffer are in use? */
    unsigned int soff;
    PGresult *res;
    int ret;
    ConnStatusType status;
 
    off = 0;
    soff = 0;
    for (unsigned int i = 0; 0 != params[i].num_params; i++)
    {
      const struct GNUNET_PQ_QueryParam *x = &params[i];
 
      ret = x->conv (x->conv_cls,
                     x->data,
                     x->size,
                     &param_values[off],
                     &param_lengths[off],
                     &param_formats[off],
                     x->num_params,
                     &scratch[soff],
                     len - soff);
      if (ret < 0)
      {
        for (off = 0; off < soff; off++)
          GNUNET_free (scratch[off]);
        return NULL;
      }
      soff += ret;
      off += x->num_params;
    }
    GNUNET_assert (off == len);
    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                     "pq",
                     "Executing prepared SQL statement `%s'\n",
                     name);
    res = PQexecPrepared (db->conn,
                          name,
                          len,
                          (const char **) param_values,
                          param_lengths,
                          param_formats,
                          1);
    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                     "pq",
                     "Execution of prepared SQL statement `%s' finished (%s)\n",
                     name,
                     PQresStatus (PQresultStatus (res)));
    if ( (PGRES_COMMAND_OK != PQresultStatus (res)) &&
         (CONNECTION_OK != (status = PQstatus (db->conn))) )
    {
      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                       "pq",
                       "Database disconnected on SQL statement `%s' (reconnecting)\n",
                       name);
      GNUNET_PQ_reconnect (db);
      res = NULL;
    }
 
    for (off = 0; off < soff; off++)
      GNUNET_free (scratch[off]);
    return res;
  }
}

References GNUNET_PQ_QueryParam::conv, GNUNET_PQ_QueryParam::conv_cls, GNUNET_PQ_QueryParam::data, db, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_log_from, GNUNET_NZL, GNUNET_PQ_reconnect(), len, name, GNUNET_PQ_QueryParam::num_params, res, ret, GNUNET_PQ_QueryParam::size, and status.

Here is the call graph for this function:

GNUNET_PQ_extract_result()

enum GNUNET_GenericReturnValue GNUNET_PQ_extract_result	(	PGresult *	result,
		struct GNUNET_PQ_ResultSpec *	rs,
		int	row
	)

Extract results from a query result according to the given specification.

Parameters

	result	result to process
[in,out]	rs	result specification to extract for
	row	row from the result to extract

Returns

GNUNET_YES if all results could be extracted GNUNET_SYSERR if a result was invalid (non-existing field)

Definition at line 139 of file pq.c.

{
  unsigned int i;
 
  if (NULL == result)
    return GNUNET_SYSERR;
  for (i = 0; NULL != rs[i].conv; i++)
  {
    struct GNUNET_PQ_ResultSpec *spec;
    enum GNUNET_GenericReturnValue ret;
 
    spec = &rs[i];
    ret = spec->conv (spec->cls,
                      result,
                      row,
                      spec->fname,
                      &spec->dst_size,
                      spec->dst);
    switch (ret)
    {
    case GNUNET_OK:
      /* canonical case, continue below */
      if (NULL != spec->is_null)
        *spec->is_null = false;
      break;
    case GNUNET_NO:
      if (spec->is_nullable)
      {
        if (NULL != spec->is_null)
          *spec->is_null = true;
        continue;
      }
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "NULL field encountered for `%s' where non-NULL was required\n",
                  spec->fname);
      goto cleanup;
    case GNUNET_SYSERR:
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to extract field `%s'\n",
                  spec->fname);
      GNUNET_break (0);
      goto cleanup;
    }
    if (NULL != spec->result_size)
      *spec->result_size = spec->dst_size;
  }
  return GNUNET_OK;
cleanup:
  for (unsigned int j = 0; j < i; j++)
    if (NULL != rs[j].cleaner)
      rs[j].cleaner (rs[j].cls,
                     rs[j].dst);
  return GNUNET_SYSERR;
}

Referenced by extract_result_cb(), handle_results(), lookup_records(), process_keys(), and process_result().

Here is the caller graph for this function:

GNUNET_PQ_cleanup_result()

void GNUNET_PQ_cleanup_result

(

struct GNUNET_PQ_ResultSpec *

rs

)

Free all memory that was allocated in rs during GNUNET_PQ_extract_result().

Parameters

rs	reult specification to clean up

Definition at line 139 of file pq.c.

{
  for (unsigned int i = 0; NULL != rs[i].conv; i++)
    if (NULL != rs[i].cleaner)
      rs[i].cleaner (rs[i].cls,
                     rs[i].dst);
}

References GNUNET_PQ_ResultSpec::cleaner, and GNUNET_PQ_ResultSpec::conv.

Referenced by extract_result_cb(), handle_results(), lookup_records(), process_keys(), and process_result().

Here is the caller graph for this function:

GNUNET_PQ_eval_result()

enum GNUNET_DB_QueryStatus GNUNET_PQ_eval_result	(	struct GNUNET_PQ_Context *	db,
		const char *	statement_name,
		PGresult *	result
	)

Check the result's error code to see what happened.

Also logs errors.

Parameters

db	database to execute the statement in
statement_name	name of the statement that created result
result	result to check

Returns

status code from the result, mapping PQ status codes to enum GNUNET_DB_QueryStatus. Never returns positive values as this function does not look at the result set.

Deprecated:

(low level, let's see if we can do with just the high-level functions)

Definition at line 1 of file pq_eval.c.

{
  ExecStatusType est;
 
  if (NULL == result)
    return GNUNET_DB_STATUS_SOFT_ERROR;
  est = PQresultStatus (result);
  if ((PGRES_COMMAND_OK != est) &&
      (PGRES_TUPLES_OK != est))
  {
    const char *sqlstate;
    ConnStatusType status;
 
    if (CONNECTION_OK != (status = PQstatus (db->conn)))
    {
      GNUNET_log_from (GNUNET_ERROR_TYPE_INFO,
                       "pq",
                       "Database connection failed during query `%s': %d (reconnecting)\n",
                       statement_name,
                       status);
      GNUNET_PQ_reconnect (db);
      return GNUNET_DB_STATUS_SOFT_ERROR;
    }
 
    sqlstate = PQresultErrorField (result,
                                   PG_DIAG_SQLSTATE);
    if (NULL == sqlstate)
    {
      /* very unexpected... */
      GNUNET_break (0);
      return GNUNET_DB_STATUS_HARD_ERROR;
    }
    if ((0 == strcmp (sqlstate,
                      PQ_DIAG_SQLSTATE_DEADLOCK)) ||
        (0 == strcmp (sqlstate,
                      PQ_DIAG_SQLSTATE_SERIALIZATION_FAILURE)))
    {
      /* These two can be retried and have a fair chance of working
         the next time */
      GNUNET_log_from (GNUNET_ERROR_TYPE_INFO,
                       "pq",
                       "Query `%s' failed with result: %s/%s/%s/%s/%s\n",
                       statement_name,
                       PQresultErrorField (result,
                                           PG_DIAG_MESSAGE_PRIMARY),
                       PQresultErrorField (result,
                                           PG_DIAG_MESSAGE_DETAIL),
                       PQresultErrorMessage (result),
                       PQresStatus (PQresultStatus (result)),
                       PQerrorMessage (db->conn));
      return GNUNET_DB_STATUS_SOFT_ERROR;
    }
    if (0 == strcmp (sqlstate,
                     PQ_DIAG_SQLSTATE_UNIQUE_VIOLATION))
    {
      /* Likely no need to retry, INSERT of "same" data. */
      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                       "pq",
                       "Query `%s' failed with unique violation: %s/%s/%s/%s/%s\n",
                       statement_name,
                       PQresultErrorField (result,
                                           PG_DIAG_MESSAGE_PRIMARY),
                       PQresultErrorField (result,
                                           PG_DIAG_MESSAGE_DETAIL),
                       PQresultErrorMessage (result),
                       PQresStatus (PQresultStatus (result)),
                       PQerrorMessage (db->conn));
      return GNUNET_DB_STATUS_SUCCESS_NO_RESULTS;
    }
    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
                     "pq",
                     "Query `%s' failed with result: %s/%s/%s/%s/%s\n",
                     statement_name,
                     PQresultErrorField (result,
                                         PG_DIAG_MESSAGE_PRIMARY),
                     PQresultErrorField (result,
                                         PG_DIAG_MESSAGE_DETAIL),
                     PQresultErrorMessage (result),
                     PQresStatus (PQresultStatus (result)),
                     PQerrorMessage (db->conn));
    return GNUNET_DB_STATUS_HARD_ERROR;
  }
  return GNUNET_DB_STATUS_SUCCESS_NO_RESULTS;
}

GNUNET_PQ_eval_prepared_non_select()

enum GNUNET_DB_QueryStatus GNUNET_PQ_eval_prepared_non_select	(	struct GNUNET_PQ_Context *	db,
		const char *	statement_name,
		const struct GNUNET_PQ_QueryParam *	params
	)

Execute a named prepared statement that is NOT a SELECT statement in connection using the given params.

Returns the resulting session state.

Parameters

db	database to execute the statement with
statement_name	name of the statement
params	parameters to give to the statement (GNUNET_PQ_query_param_end-terminated)

Returns

status code from the result, mapping PQ status codes to enum GNUNET_DB_QueryStatus. If the statement was a DELETE or UPDATE statement, the number of affected rows is returned; if the statement was an INSERT statement, and no row was added due to a UNIQUE violation, we return zero; if INSERT was successful, we return one.

Definition at line 1 of file pq_eval.c.

{
  PGresult *result;
  enum GNUNET_DB_QueryStatus qs;
 
  result = GNUNET_PQ_exec_prepared (db,
                                    statement_name,
                                    params);
  if (NULL == result)
    return GNUNET_DB_STATUS_SOFT_ERROR;
  qs = GNUNET_PQ_eval_result (db,
                              statement_name,
                              result);
  if (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS == qs)
  {
    const char *tuples;
 
    /* What an awful API, this function really does return a string */
    tuples = PQcmdTuples (result);
    if (NULL != tuples)
      qs = strtol (tuples, NULL, 10);
  }
  PQclear (result);
  return qs;
}

Referenced by delete_old_block(), namecache_postgres_expire_blocks(), postgres_plugin_put(), postgres_plugin_remove_key(), process_result(), and repl_proc().

Here is the caller graph for this function:

GNUNET_PQ_eval_prepared_multi_select()

enum GNUNET_DB_QueryStatus GNUNET_PQ_eval_prepared_multi_select	(	struct GNUNET_PQ_Context *	db,
		const char *	statement_name,
		const struct GNUNET_PQ_QueryParam *	params,
		GNUNET_PQ_PostgresResultHandler	rh,
		void *	rh_cls
	)

Execute a named prepared statement that is a SELECT statement which may return multiple results in connection using the given params.

Call rh with the results. Returns the query status including the number of results given to rh (possibly zero). rh will not have been called if the return value is negative.

Parameters

db	database to execute the statement with
statement_name	name of the statement
params	parameters to give to the statement (GNUNET_PQ_query_param_end-terminated)
rh	function to call with the result set, NULL to ignore
rh_cls	closure to pass to rh

Returns

status code from the result, mapping PQ status codes to enum GNUNET_DB_QueryStatus.

Definition at line 1 of file pq_eval.c.

{
  PGresult *result;
  enum GNUNET_DB_QueryStatus qs;
  unsigned int ret;
 
  result = GNUNET_PQ_exec_prepared (db,
                                    statement_name,
                                    params);
  if (NULL == result)
    return GNUNET_DB_STATUS_SOFT_ERROR;
  qs = GNUNET_PQ_eval_result (db,
                              statement_name,
                              result);
  if (qs < 0)
  {
    PQclear (result);
    return qs;
  }
  ret = PQntuples (result);
  if (NULL != rh)
    rh (rh_cls,
        result,
        ret);
  PQclear (result);
  return ret;
}

Referenced by postgres_plugin_del(), postgres_plugin_get_closest(), postgres_plugin_get_expiration(), postgres_plugin_get_key(), postgres_plugin_get_keys(), postgres_plugin_get_replication(), and postgres_plugin_get_zero_anonymity().

Here is the caller graph for this function:

GNUNET_PQ_eval_prepared_singleton_select()

enum GNUNET_DB_QueryStatus GNUNET_PQ_eval_prepared_singleton_select	(	struct GNUNET_PQ_Context *	db,
		const char *	statement_name,
		const struct GNUNET_PQ_QueryParam *	params,
		struct GNUNET_PQ_ResultSpec *	rs
	)

Execute a named prepared statement that is a SELECT statement which must return a single result in connection using the given params.

Stores the result (if any) in rs, which the caller must then clean up using GNUNET_PQ_cleanup_result() if the return value was GNUNET_DB_STATUS_SUCCESS_ONE_RESULT. Returns the resulting session status.

Parameters

	db	database to execute the statement with
	statement_name	name of the statement
	params	parameters to give to the statement (GNUNET_PQ_query_param_end-terminated)
[in,out]	rs	result specification to use for storing the result of the query

Returns

status code from the result, mapping PQ status codes to enum GNUNET_DB_QueryStatus.

Definition at line 1 of file pq_eval.c.

{
  PGresult *result;
  enum GNUNET_DB_QueryStatus qs;
  int ntuples;
 
  result = GNUNET_PQ_exec_prepared (db,
                                    statement_name,
                                    params);
  if (NULL == result)
    return GNUNET_DB_STATUS_SOFT_ERROR;
  qs = GNUNET_PQ_eval_result (db,
                              statement_name,
                              result);
  if (qs < 0)
  {
    PQclear (result);
    return qs;
  }
  ntuples = PQntuples (result);
  if (0 == ntuples)
  {
    PQclear (result);
    return GNUNET_DB_STATUS_SUCCESS_NO_RESULTS;
  }
  if (1 != ntuples)
  {
    /* more than one result, but there must be at most one */
    GNUNET_break (0);
    PQclear (result);
    return GNUNET_DB_STATUS_HARD_ERROR;
  }
  if (GNUNET_OK !=
      GNUNET_PQ_extract_result (result,
                                rs,
                                0))
  {
    PQclear (result);
    return GNUNET_DB_STATUS_HARD_ERROR;
  }
  PQclear (result);
  return GNUNET_DB_STATUS_SUCCESS_ONE_RESULT;
}

Referenced by postgres_plugin_estimate_size().

Here is the caller graph for this function:

GNUNET_PQ_make_prepare()

struct GNUNET_PQ_PreparedStatement GNUNET_PQ_make_prepare	(	const char *	name,
		const char *	sql
	)

Create a struct GNUNET_PQ_PreparedStatement.

Parameters

name	name of the statement
sql	actual SQL statement

Returns

initialized struct

Definition at line 1 of file pq_prepare.c.

{
  struct GNUNET_PQ_PreparedStatement ps = {
    .name = name,
    .sql = sql
  };
 
  return ps;
}

References name, GNUNET_PQ_PreparedStatement::name, and GNUNET_PQ_PreparedStatement::sql.

GNUNET_PQ_prepare_statements()

enum GNUNET_GenericReturnValue GNUNET_PQ_prepare_statements	(	struct GNUNET_PQ_Context *	db,
		const struct GNUNET_PQ_PreparedStatement *	ps
	)

Request creation of prepared statements ps from Postgres.

Parameters

db	database to prepare the statements for
ps	GNUNET_PQ_PREPARED_STATEMENT_END-terminated array of prepared statements.

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1 of file pq_prepare.c.

{
  if (db->ps != ps)
  {
    /* add 'ps' to list db->ps of prepared statements to run on reconnect! */
    unsigned int nlen = 0; /* length of 'ps' array */
    unsigned int xlen;
    struct GNUNET_PQ_PreparedStatement *rps; /* combined array */
 
    while (NULL != ps[nlen].name)
      nlen++;
    xlen = nlen + db->ps_off;
    if (xlen > db->ps_len)
    {
      xlen = 2 * xlen + 1;
      rps = GNUNET_new_array (xlen,
                              struct GNUNET_PQ_PreparedStatement);
      if (NULL != db->ps)
        memcpy (rps,
                db->ps,
                db->ps_off * sizeof (struct GNUNET_PQ_PreparedStatement));
      GNUNET_free (db->ps);
      db->ps_len = xlen;
      db->ps = rps;
    }
    memcpy (&db->ps[db->ps_off],
            ps,
            nlen * sizeof (struct GNUNET_PQ_PreparedStatement));
    db->ps_off += nlen;
  }
 
  return GNUNET_PQ_prepare_once (db,
                                 ps);
}

Referenced by GNUNET_PQ_reconnect().

Here is the caller graph for this function:

GNUNET_PQ_prepare_once()

enum GNUNET_GenericReturnValue GNUNET_PQ_prepare_once	(	struct GNUNET_PQ_Context *	db,
		const struct GNUNET_PQ_PreparedStatement *	ps
	)

Request creation of prepared statements ps from Postgres, but do not automatically re-prepare the statement if we are disconnected from the database.

Parameters

db	database to prepare the statements for
ps	GNUNET_PQ_PREPARED_STATEMENT_END-terminated array of prepared statements.

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1 of file pq_prepare.c.

{
  for (unsigned int i = 0; NULL != ps[i].name; i++)
  {
    PGresult *ret;
 
    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                     "pq",
                     "Preparing SQL statement `%s' as `%s'\n",
                     ps[i].sql,
                     ps[i].name);
    ret = PQprepare (db->conn,
                     ps[i].name,
                     ps[i].sql,
                     0,
                     NULL);
    if (PGRES_COMMAND_OK != PQresultStatus (ret))
    {
      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                       "pq",
                       "PQprepare (`%s' as `%s') failed with error: %s\n",
                       ps[i].sql,
                       ps[i].name,
                       PQerrorMessage (db->conn));
      PQclear (ret);
      ret = PQdescribePrepared (db->conn,
                                ps[i].name);
      if (PGRES_COMMAND_OK != PQresultStatus (ret))
      {
        PQclear (ret);
        return GNUNET_SYSERR;
      }
      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
                       "pq",
                       "Statement `%s' already known. Ignoring the issue in the hope that you are using connection pooling...\n",
                       ps[i].name);
    }
    PQclear (ret);
  }
  return GNUNET_OK;
}

GNUNET_PQ_make_execute()

struct GNUNET_PQ_ExecuteStatement GNUNET_PQ_make_execute

(

const char *

sql

)

Create a struct GNUNET_PQ_ExecuteStatement where errors are fatal.

Parameters

sql	actual SQL statement

Returns

initialized struct

Definition at line 1 of file pq_exec.c.

{
  struct GNUNET_PQ_ExecuteStatement es = {
    .sql = sql,
    .ignore_errors = GNUNET_NO
  };
 
  return es;
}

Referenced by postgres_plugin_drop().

Here is the caller graph for this function:

GNUNET_PQ_make_try_execute()

struct GNUNET_PQ_ExecuteStatement GNUNET_PQ_make_try_execute

(

const char *

sql

)

Create a struct GNUNET_PQ_ExecuteStatement where errors should be tolerated.

Parameters

sql	actual SQL statement

Returns

initialized struct

Definition at line 1 of file pq_exec.c.

{
  struct GNUNET_PQ_ExecuteStatement es = {
    .sql = sql,
    .ignore_errors = GNUNET_YES
  };
 
  return es;
}

GNUNET_PQ_exec_statements()

enum GNUNET_GenericReturnValue GNUNET_PQ_exec_statements	(	struct GNUNET_PQ_Context *	db,
		const struct GNUNET_PQ_ExecuteStatement *	es
	)

Request execution of an array of statements es from Postgres.

Parameters

db	database to execute the statements in
es	GNUNET_PQ_PREPARED_STATEMENT_END-terminated array of prepared statements.

Returns

GNUNET_OK on success (modulo statements where errors can be ignored) GNUNET_SYSERR on error

Definition at line 1 of file pq_exec.c.

{
  for (unsigned int i = 0; NULL != es[i].sql; i++)
  {
    PGresult *result;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Running statement `%s' on %p\n",
                es[i].sql,
                db);
    result = PQexec (db->conn,
                     es[i].sql);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Running statement `%s' on %p finished (%s)\n",
                es[i].sql,
                db,
                PQresStatus (PQresultStatus (result)));
    if ((GNUNET_NO == es[i].ignore_errors) &&
        (PGRES_COMMAND_OK != PQresultStatus (result)))
    {
      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
                       "pq",
                       "Failed to execute `%s': %s/%s/%s/%s/%s",
                       es[i].sql,
                       PQresultErrorField (result,
                                           PG_DIAG_MESSAGE_PRIMARY),
                       PQresultErrorField (result,
                                           PG_DIAG_MESSAGE_DETAIL),
                       PQresultErrorMessage (result),
                       PQresStatus (PQresultStatus (result)),
                       PQerrorMessage (db->conn));
      PQclear (result);
      return GNUNET_SYSERR;
    }
    PQclear (result);
  }
  return GNUNET_OK;
}

References GNUNET_NO, and GNUNET_PQ_ExecuteStatement::sql.

Referenced by GNUNET_PQ_reconnect(), and postgres_plugin_drop().

Here is the caller graph for this function:

GNUNET_PQ_connect()

struct GNUNET_PQ_Context* GNUNET_PQ_connect	(	const char *	config_str,
		const char *	load_path,
		const struct GNUNET_PQ_ExecuteStatement *	es,
		const struct GNUNET_PQ_PreparedStatement *	ps
	)

Create a connection to the Postgres database using config_str for the configuration.

Initialize logging via GNUnet's log routines and disable Postgres's logger. Also ensures that the statements in load_path and es are executed whenever we (re)connect to the database, and that the prepared statements in ps are "ready". If statements in es fail that were created with GNUNET_PQ_make_execute(), then the entire operation fails.

In load_path, a list of "$XXXX.sql" files is expected where $XXXX must be a sequence of contiguous integer values starting at 0000. These files are then loaded in sequence using "psql $config_str" before running statements from es. The directory is inspected again on reconnect.

Parameters

config_str	configuration to use
load_path	path to directory with SQL transactions to run, can be NULL
es	GNUNET_PQ_PREPARED_STATEMENT_END-terminated array of statements to execute upon EACH connection, can be NULL
ps	array of prepared statements to prepare, can be NULL

Returns

NULL on error

Definition at line 69 of file pq_connect.c.

{
  return GNUNET_PQ_connect2 (config_str,
                             load_path,
                             NULL == load_path
                             ? NULL
                             : "",
                             es,
                             ps,
                             GNUNET_PQ_FLAG_NONE);
}

References GNUNET_PQ_Context::config_str, GNUNET_PQ_Context::es, GNUNET_PQ_connect2(), GNUNET_PQ_FLAG_NONE, GNUNET_PQ_Context::load_path, and GNUNET_PQ_Context::ps.

Here is the call graph for this function:

GNUNET_PQ_exec_sql()

enum GNUNET_GenericReturnValue GNUNET_PQ_exec_sql	(	struct GNUNET_PQ_Context *	db,
		const char *	buf
	)

Execute SQL statements from buf against db.

The given filename infix in buf is prefixed with the "load_path" and ".sql" is appended to construct the full filename.

Parameters

db	database context to use
buf	filename infix (!) with the SQL code to run

Returns

GNUNET_OK on success, GNUNET_NO if patch buf does not exist, GNUNET_SYSERR on error

Definition at line 86 of file pq_connect.c.

{
  struct GNUNET_OS_Process *psql;
  enum GNUNET_OS_ProcessStatusType type;
  unsigned long code;
  enum GNUNET_GenericReturnValue ret;
  char *fn;
 
  GNUNET_asprintf (&fn,
                   "%s%s.sql",
                   db->load_path,
                   buf);
  if (GNUNET_YES !=
      GNUNET_DISK_file_test (fn))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "SQL resource `%s' does not exist\n",
                fn);
    GNUNET_free (fn);
    return GNUNET_NO;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Applying SQL file `%s' on database %s\n",
              fn,
              db->config_str);
  psql = GNUNET_OS_start_process (GNUNET_OS_INHERIT_STD_NONE,
                                  NULL,
                                  NULL,
                                  NULL,
                                  "psql",
                                  "psql",
                                  db->config_str,
                                  "-f",
                                  fn,
                                  "-q",
                                  "--set",
                                  "ON_ERROR_STOP=1",
                                  NULL);
  if (NULL == psql)
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                              "exec",
                              "psql");
    GNUNET_free (fn);
    return GNUNET_SYSERR;
  }
  ret = GNUNET_OS_process_wait_status (psql,
                                       &type,
                                       &code);
  if (GNUNET_OK != ret)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "psql on file %s did not finish, killed it!\n",
                fn);
    /* can happen if we got a signal, like CTRL-C, before
       psql was complete */
    (void) GNUNET_OS_process_kill (psql,
                                   SIGKILL);
    GNUNET_OS_process_destroy (psql);
    GNUNET_free (fn);
    return GNUNET_SYSERR;
  }
  GNUNET_OS_process_destroy (psql);
  if ( (GNUNET_OS_PROCESS_EXITED != type) ||
       (0 != code) )
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Could not run PSQL on file %s: psql exit code was %d\n",
                fn,
                (int) code);
    GNUNET_free (fn);
    return GNUNET_SYSERR;
  }
  GNUNET_free (fn);
  return GNUNET_OK;
}

Referenced by GNUNET_PQ_reconnect(), and libgnunet_plugin_datacache_postgres_done().

Here is the caller graph for this function:

GNUNET_PQ_connect2()

struct GNUNET_PQ_Context* GNUNET_PQ_connect2	(	const char *	config_str,
		const char *	load_path,
		const char *	auto_suffix,
		const struct GNUNET_PQ_ExecuteStatement *	es,
		const struct GNUNET_PQ_PreparedStatement *	ps,
		enum GNUNET_PQ_Options	flags
	)

Create a connection to the Postgres database using config_str for the configuration.

Initialize logging via GNUnet's log routines and disable Postgres's logger. Also ensures that the statements in load_path and es are executed whenever we (re)connect to the database, and that the prepared statements in ps are "ready". If statements in es fail that were created with GNUNET_PQ_make_execute(), then the entire operation fails.

In load_path, a list of "$XXXX.sql" files is expected where $XXXX must be a sequence of contiguous integer values starting at 0000. These files are then loaded in sequence using "psql $config_str" before running statements from es. The directory is inspected again on reconnect.

Parameters

config_str	configuration to use
load_path	path to directory with SQL transactions to run, can be NULL
auto_suffix	infix of SQL series to run on every reconnect; runs multiple (!) files, of the form auto_suffix-XXXX where XXXX is from 0 to 9999 (consequtive).
es	GNUNET_PQ_PREPARED_STATEMENT_END-terminated array of statements to execute upon EACH connection, can be NULL
ps	array of prepared statements to prepare, can be NULL
flags	connection flags

Returns

NULL on error

Definition at line 86 of file pq_connect.c.

{
  struct GNUNET_PQ_Context *db;
  unsigned int elen = 0;
  unsigned int plen = 0;
 
  if (NULL != es)
    while (NULL != es[elen].sql)
      elen++;
  if (NULL != ps)
    while (NULL != ps[plen].name)
      plen++;
 
  db = GNUNET_new (struct GNUNET_PQ_Context);
  db->flags = flags;
  db->config_str = GNUNET_strdup (config_str);
  if (NULL != load_path)
    db->load_path = GNUNET_strdup (load_path);
  if (NULL != auto_suffix)
    db->auto_suffix = GNUNET_strdup (auto_suffix);
  if (0 != elen)
  {
    db->es = GNUNET_new_array (elen + 1,
                               struct GNUNET_PQ_ExecuteStatement);
    memcpy (db->es,
            es,
            elen * sizeof (struct GNUNET_PQ_ExecuteStatement));
  }
  if (0 != plen)
  {
    db->ps = GNUNET_new_array (plen + 1,
                               struct GNUNET_PQ_PreparedStatement);
    memcpy (db->ps,
            ps,
            plen * sizeof (struct GNUNET_PQ_PreparedStatement));
  }
  db->channel_map = GNUNET_CONTAINER_multishortmap_create (16,
                                                           GNUNET_YES);
  GNUNET_PQ_reconnect (db);
  if (NULL == db->conn)
  {
    GNUNET_CONTAINER_multishortmap_destroy (db->channel_map);
    GNUNET_free (db->load_path);
    GNUNET_free (db->auto_suffix);
    GNUNET_free (db->config_str);
    GNUNET_free (db);
    return NULL;
  }
  return db;
}

References GNUNET_PQ_Context::auto_suffix, GNUNET_PQ_Context::config_str, db, GNUNET_PQ_Context::es, GNUNET_PQ_Context::flags, GNUNET_CONTAINER_multishortmap_create(), GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_free, GNUNET_new, GNUNET_new_array, GNUNET_PQ_reconnect(), GNUNET_strdup, GNUNET_YES, GNUNET_PQ_Context::load_path, name, and GNUNET_PQ_Context::ps.

Referenced by GNUNET_PQ_connect(), and GNUNET_PQ_connect_with_cfg2().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_connect_with_cfg()

struct GNUNET_PQ_Context* GNUNET_PQ_connect_with_cfg	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	load_path_suffix,
		const struct GNUNET_PQ_ExecuteStatement *	es,
		const struct GNUNET_PQ_PreparedStatement *	ps
	)

Connect to a postgres database using the configuration option "CONFIG" in section.

Also ensures that the statements in es are executed whenever we (re)connect to the database, and that the prepared statements in ps are "ready".

The caller does not have to ensure that es and ps remain allocated and initialized in memory until GNUNET_PQ_disconnect() is called, as a copy will be made.

Parameters

cfg	configuration
section	configuration section to use to get Postgres configuration options
load_path_suffix	suffix to append to the SQL_DIR in the configuration
es	GNUNET_PQ_PREPARED_STATEMENT_END-terminated array of statements to execute upon EACH connection, can be NULL
ps	array of prepared statements to prepare, can be NULL

Returns

the postgres handle, NULL on error

Definition at line 619 of file pq_connect.c.

{
  return GNUNET_PQ_connect_with_cfg2 (cfg,
                                      section,
                                      load_path_suffix,
                                      es,
                                      ps,
                                      GNUNET_PQ_FLAG_NONE);
}

References cfg, GNUNET_PQ_Context::es, GNUNET_PQ_connect_with_cfg2(), GNUNET_PQ_FLAG_NONE, and GNUNET_PQ_Context::ps.

Here is the call graph for this function:

GNUNET_PQ_connect_with_cfg2()

struct GNUNET_PQ_Context* GNUNET_PQ_connect_with_cfg2	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	section,
		const char *	load_path_suffix,
		const struct GNUNET_PQ_ExecuteStatement *	es,
		const struct GNUNET_PQ_PreparedStatement *	ps,
		enum GNUNET_PQ_Options	flags
	)

Connect to a postgres database using the configuration option "CONFIG" in section.

Also ensures that the statements in es are executed whenever we (re)connect to the database, and that the prepared statements in ps are "ready".

The caller does not have to ensure that es and ps remain allocated and initialized in memory until GNUNET_PQ_disconnect() is called, as a copy will be made.

Parameters

cfg	configuration
section	configuration section to use to get Postgres configuration options
load_path_suffix	suffix to append to the SQL_DIR in the configuration
es	GNUNET_PQ_PREPARED_STATEMENT_END-terminated array of statements to execute upon EACH connection, can be NULL
ps	array of prepared statements to prepare, can be NULL
flags	connection flags

Returns

the postgres handle, NULL on error

Definition at line 635 of file pq_connect.c.

{
  struct GNUNET_PQ_Context *db;
  char *conninfo;
  char *load_path;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             section,
                                             "CONFIG",
                                             &conninfo))
    conninfo = NULL;
  load_path = NULL;
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (cfg,
                                               section,
                                               "SQL_DIR",
                                               &load_path))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_INFO,
                               section,
                               "SQL_DIR");
  }
  if ( (NULL != load_path_suffix) &&
       (NULL == load_path) )
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               section,
                               "SQL_DIR");
    return NULL;
  }
  db = GNUNET_PQ_connect2 (conninfo == NULL ? "" : conninfo,
                           load_path,
                           load_path_suffix,
                           es,
                           ps,
                           flags);
  GNUNET_free (load_path);
  GNUNET_free (conninfo);
  return db;
}

References cfg, db, GNUNET_PQ_Context::es, GNUNET_PQ_Context::flags, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log_config_missing(), GNUNET_OK, GNUNET_PQ_connect2(), GNUNET_PQ_Context::load_path, and GNUNET_PQ_Context::ps.

Referenced by GNUNET_PQ_connect_with_cfg().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_reconnect_if_down()

void GNUNET_PQ_reconnect_if_down

(

struct GNUNET_PQ_Context *

db

)

Reinitialize the database db if the connection is down.

Parameters

db	database connection to reinitialize

Definition at line 314 of file pq_connect.c.

{
  if (1 ==
      PQconsumeInput (db->conn))
    return;
  if (CONNECTION_BAD != PQstatus (db->conn))
    return;
  GNUNET_PQ_reconnect (db);
}

GNUNET_PQ_reconnect()

void GNUNET_PQ_reconnect

(

struct GNUNET_PQ_Context *

db

)

Reinitialize the database db.

Parameters

db	database connection to reinitialize

Definition at line 427 of file pq_connect.c.

{
  GNUNET_PQ_event_reconnect_ (db,
                              -1);
  if (NULL != db->conn)
    PQfinish (db->conn);
  db->conn = PQconnectdb (db->config_str);
  if ( (NULL == db->conn) ||
       (CONNECTION_OK != PQstatus (db->conn)) )
  {
    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
                     "pq",
                     "Database connection to '%s' failed: %s\n",
                     db->config_str,
                     (NULL != db->conn)
                     ? PQerrorMessage (db->conn)
                     : "PQconnectdb returned NULL");
    if (NULL != db->conn)
    {
      PQfinish (db->conn);
      db->conn = NULL;
    }
    return;
  }
  PQsetNoticeReceiver (db->conn,
                       &pq_notice_receiver_cb,
                       db);
  PQsetNoticeProcessor (db->conn,
                        &pq_notice_processor_cb,
                        db);
  if (NULL != db->load_path)
  {
    PGresult *res;
    ExecStatusType est;
 
    res = PQexec (db->conn,
                  "SELECT"
                  " schema_name"
                  " FROM information_schema.schemata"
                  " WHERE schema_name='_v';");
    est = PQresultStatus (res);
    if ( (PGRES_COMMAND_OK != est) &&
         (PGRES_TUPLES_OK != est) )
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to run statement to check versioning schema. Bad!\n");
      PQclear (res);
      PQfinish (db->conn);
      db->conn = NULL;
      return;
    }
    if (0 == PQntuples (res))
    {
      enum GNUNET_GenericReturnValue ret;
 
      PQclear (res);
      if (0 != (db->flags & GNUNET_PQ_FLAG_DROP))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                    "Versioning schema does not exist yet. Not attempting drop!\n");
        PQfinish (db->conn);
        db->conn = NULL;
        return;
      }
      ret = GNUNET_PQ_exec_sql (db,
                                "versioning");
      if (GNUNET_NO == ret)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Failed to find SQL file to load database versioning logic\n");
        PQfinish (db->conn);
        db->conn = NULL;
        return;
      }
      if (GNUNET_SYSERR == ret)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Failed to run SQL logic to setup database versioning logic\n");
        PQfinish (db->conn);
        db->conn = NULL;
        return;
      }
    }
    else
    {
      PQclear (res);
    }
  }
 
  /* Prepare statement for OID lookup by name */
  {
    PGresult *res;
 
    res = PQprepare (db->conn,
                     "gnunet_pq_get_oid_by_name",
                     "SELECT"
                     " typname, oid"
                     " FROM pg_type"
                     " WHERE typname = $1"
                     " LIMIT 1",
                     1,
                     NULL);
    if (PGRES_COMMAND_OK != PQresultStatus (res))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to run SQL statement prepare OID lookups: %s/%s\n",
                  PQresultErrorMessage (res),
                  PQerrorMessage (db->conn));
      PQclear (res);
      PQfinish (db->conn);
      db->conn = NULL;
      return;
    }
    PQclear (res);
  }
 
  /* Reset the OID-cache and retrieve the OIDs for the supported Array types */
  db->oids.num = 0;
  if (GNUNET_SYSERR == load_initial_oids (db))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to retrieve OID information for array types!\n");
    PQfinish (db->conn);
    db->conn = NULL;
    return;
  }
 
 
  if (NULL != db->auto_suffix)
  {
    PGresult *res;
 
    GNUNET_assert (NULL != db->load_path);
    res = PQprepare (db->conn,
                     "gnunet_pq_check_patch",
                     "SELECT"
                     " applied_by"
                     " FROM _v.patches"
                     " WHERE patch_name = $1"
                     " LIMIT 1",
                     1,
                     NULL);
    if (PGRES_COMMAND_OK != PQresultStatus (res))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to run SQL logic to setup database versioning logic: %s/%s\n",
                  PQresultErrorMessage (res),
                  PQerrorMessage (db->conn));
      PQclear (res);
      PQfinish (db->conn);
      db->conn = NULL;
      return;
    }
    PQclear (res);
 
    if (GNUNET_SYSERR ==
        GNUNET_PQ_run_sql (db,
                           db->auto_suffix))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Failed to load SQL statements from `%s*'\n",
                  db->auto_suffix);
      PQfinish (db->conn);
      db->conn = NULL;
      return;
    }
  }
 
  if ( (NULL != db->es) &&
       (GNUNET_OK !=
        GNUNET_PQ_exec_statements (db,
                                   db->es)) )
  {
    PQfinish (db->conn);
    db->conn = NULL;
    return;
  }
  if ( (NULL != db->ps) &&
       (GNUNET_OK !=
        GNUNET_PQ_prepare_statements (db,
                                      db->ps)) )
  {
    PQfinish (db->conn);
    db->conn = NULL;
    return;
  }
  GNUNET_PQ_event_reconnect_ (db,
                              PQsocket (db->conn));
}

References db, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_from, GNUNET_NO, GNUNET_OK, GNUNET_PQ_event_reconnect_(), GNUNET_PQ_exec_sql(), GNUNET_PQ_exec_statements(), GNUNET_PQ_FLAG_DROP, GNUNET_PQ_prepare_statements(), GNUNET_PQ_run_sql(), GNUNET_SYSERR, load_initial_oids(), pq_notice_processor_cb(), pq_notice_receiver_cb(), res, and ret.

Referenced by do_scheduler_notify(), GNUNET_PQ_connect2(), GNUNET_PQ_event_do_poll(), GNUNET_PQ_exec_prepared(), and load_initial_oids().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_event_listen()

struct GNUNET_DB_EventHandler* GNUNET_PQ_event_listen	(	struct GNUNET_PQ_Context *	db,
		const struct GNUNET_DB_EventHeaderP *	es,
		struct GNUNET_TIME_Relative	timeout,
		GNUNET_DB_EventCallback	cb,
		void *	cb_cls
	)

Register callback to be invoked on events of type es.

Unlike many other calls, this function is thread-safe and may be called from threads that are different from the one that setup db. However, the cb will always be called from the thread that runs GNUNET_PQ_event_do_poll() or the GNUnet scheduler.

Parameters

db	database context to use
es	specification of the event to listen for
timeout	when to trigger cb based on timeout
cb	function to call when the event happens, possibly multiple times (until GNUNET_PQ_event_listen_cancel() is invoked), including on timeout
cb_cls	closure for cb

Returns

handle useful to cancel the listener

Definition at line 445 of file pq_event.c.

{
  struct GNUNET_DB_EventHandler *eh;
  bool sub;
 
  eh = GNUNET_new (struct GNUNET_DB_EventHandler);
  eh->db = db;
  es_to_sh (es,
            &eh->sh);
  eh->cb = cb;
  eh->cb_cls = cb_cls;
  sub = (NULL ==
         GNUNET_CONTAINER_multishortmap_get (db->channel_map,
                                             &eh->sh));
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multishortmap_put (db->channel_map,
                                                     &eh->sh,
                                                     eh,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
  if (NULL == db->event_task)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Starting event scheduler\n");
    scheduler_fd_cb (db,
                     PQsocket (db->conn));
  }
  if (sub)
    manage_subscribe (db,
                      "LISTEN X",
                      eh);
  eh->timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
                                                   &event_timeout,
                                                   eh);
  return eh;
}

References GNUNET_DB_EventHandler::cb, GNUNET_DB_EventHandler::cb_cls, db, GNUNET_DB_EventHandler::db, es_to_sh(), event_timeout(), GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multishortmap_get(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), manage_subscribe(), scheduler_fd_cb(), GNUNET_DB_EventHandler::sh, timeout, and GNUNET_DB_EventHandler::timeout_task.

Here is the call graph for this function:

GNUNET_PQ_event_listen_cancel()

void GNUNET_PQ_event_listen_cancel

(

struct GNUNET_DB_EventHandler *

eh

)

Stop notifications.

Unlike many other calls, this function is thread-safe and may be called from threads that are different from the one that setup db. However, the cb will always be called from the thread that runs GNUNET_PQ_event_do_poll() or the GNUnet scheduler.

Parameters

eh	handle to unregister.

Definition at line 487 of file pq_event.c.

{
  struct GNUNET_PQ_Context *db = eh->db;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multishortmap_remove (db->channel_map,
                                                        &eh->sh,
                                                        eh));
  if (NULL ==
      GNUNET_CONTAINER_multishortmap_get (db->channel_map,
                                          &eh->sh))
    manage_subscribe (db,
                      "UNLISTEN X",
                      eh);
  if (0 == GNUNET_CONTAINER_multishortmap_size (db->channel_map))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Stopping PQ event scheduler job\n");
    GNUNET_free (db->rfd);
    if (NULL != db->event_task)
    {
      GNUNET_SCHEDULER_cancel (db->event_task);
      db->event_task = NULL;
    }
  }
  if (NULL != eh->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (eh->timeout_task);
    eh->timeout_task = NULL;
  }
  GNUNET_free (eh);
}

References db, GNUNET_DB_EventHandler::db, GNUNET_assert, GNUNET_CONTAINER_multishortmap_get(), GNUNET_CONTAINER_multishortmap_remove(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_cancel(), manage_subscribe(), GNUNET_DB_EventHandler::sh, and GNUNET_DB_EventHandler::timeout_task.

Here is the call graph for this function:

GNUNET_PQ_event_do_poll()

void GNUNET_PQ_event_do_poll

(

struct GNUNET_PQ_Context *

db

)

Poll for events right now.

Useful if we may have triggered an event for ourselves. Not needed when using GNUNET_PQ_event_notify(), but useful when stored procedures may have triggered events. Does nothing if there are no events.

Parameters

[in,out]

db

database to check for events

Definition at line 189 of file pq_event.c.

{
  PGnotify *n;
  unsigned int cnt = 0;
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "PG poll job active\n");
  if (1 !=
      PQconsumeInput (db->conn))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to read from Postgres: %s\n",
                PQerrorMessage (db->conn));
    if (CONNECTION_BAD != PQstatus (db->conn))
      return;
    GNUNET_PQ_reconnect (db);
    return;
  }
  while (NULL != (n = PQnotifies (db->conn)))
  {
    struct GNUNET_ShortHashCode sh;
    struct NotifyContext ctx = {
      .extra = NULL
    };
 
    cnt++;
    if ('X' != toupper ((int) n->relname[0]))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Ignoring notification for unsupported channel identifier `%s'\n",
                  n->relname);
      PQfreemem (n);
      continue;
    }
    if (GNUNET_OK !=
        channel_to_sh (&n->relname[1],
                       &sh))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Ignoring notification for unsupported channel identifier `%s'\n",
                  n->relname);
      PQfreemem (n);
      continue;
    }
    if ( (NULL != n->extra) &&
         (GNUNET_OK !=
          GNUNET_STRINGS_string_to_data_alloc (n->extra,
                                               strlen (n->extra),
                                               &ctx.extra,
                                               &ctx.extra_size)))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Ignoring notification for unsupported extra data `%s' on channel `%s'\n",
                  n->extra,
                  n->relname);
      PQfreemem (n);
      continue;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Received notification %s with extra data `%.*s'\n",
                n->relname,
                (int) ctx.extra_size,
                (const char *) ctx.extra);
    GNUNET_CONTAINER_multishortmap_get_multiple (db->channel_map,
                                                 &sh,
                                                 &do_notify,
                                                 &ctx);
    GNUNET_free (ctx.extra);
    PQfreemem (n);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "PG poll job finishes after %u events\n",
              cnt);
}

References channel_to_sh(), ctx, db, do_notify(), GNUNET_CONTAINER_multishortmap_get_multiple(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_PQ_reconnect(), GNUNET_STRINGS_string_to_data_alloc(), and sh.

Referenced by do_scheduler_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_event_notify()

void GNUNET_PQ_event_notify	(	struct GNUNET_PQ_Context *	db,
		const struct GNUNET_DB_EventHeaderP *	es,
		const void *	extra,
		size_t	extra_size
	)

Notify all that listen on es of an event.

Unlike many other calls, this function is thread-safe and may be called from threads that are different from the one that setup db. However, the cb will always be called from the thread that runs GNUNET_PQ_event_do_poll() or the GNUnet scheduler.

Parameters

db	database context to use
es	specification of the event to generate
extra	additional event data provided
extra_size	number of bytes in extra

Definition at line 537 of file pq_event.c.

{
  char sql[16 + 64 + extra_size * 8 / 5 + 8];
  char *end;
  PGresult *result;
 
  end = stpcpy (sql,
                "NOTIFY X");
  end = es_to_channel (es,
                       end);
  end = stpcpy (end,
                ", '");
  end = GNUNET_STRINGS_data_to_string (extra,
                                       extra_size,
                                       end,
                                       sizeof (sql) - (end - sql) - 1);
  GNUNET_assert (NULL != end);
  *end = '\0';
  end = stpcpy (end,
                "'");
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Executing command `%s'\n",
              sql);
  result = PQexec (db->conn,
                   sql);
  if (PGRES_COMMAND_OK != PQresultStatus (result))
  {
    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
                     "pq",
                     "Failed to execute `%s': %s/%s/%s/%s/%s",
                     sql,
                     PQresultErrorField (result,
                                         PG_DIAG_MESSAGE_PRIMARY),
                     PQresultErrorField (result,
                                         PG_DIAG_MESSAGE_DETAIL),
                     PQresultErrorMessage (result),
                     PQresStatus (PQresultStatus (result)),
                     PQerrorMessage (db->conn));
  }
  PQclear (result);
  GNUNET_PQ_event_do_poll (db);
}

GNUNET_PG_get_event_notify_channel()

char* GNUNET_PG_get_event_notify_channel

(

const struct GNUNET_DB_EventHeaderP *

es

)

Compute the channel that one should notify upon for the given event specification.

Parameters

es	event specification

Returns

channel to notify upon

Definition at line 522 of file pq_event.c.

{
  char sql[16 + 64 + 8];
  char *end;
 
  end = stpcpy (sql,
                "X");
  end = es_to_channel (es,
                       end);
  GNUNET_assert (NULL != end);
  return GNUNET_strdup (sql);
}

References end, GNUNET_PQ_Context::es, es_to_channel(), GNUNET_assert, and GNUNET_strdup.

Here is the call graph for this function:

GNUNET_PQ_run_sql()

enum GNUNET_GenericReturnValue GNUNET_PQ_run_sql	(	struct GNUNET_PQ_Context *	db,
		const char *	load_path
	)

Within the db context, run all the SQL files from the load_path from 0000-9999.sql (as long as the files exist contiguously).

Parameters

db	database context to use
load_path	where to find the XXXX.sql files

Returns

GNUNET_OK on success

Definition at line 86 of file pq_connect.c.

{
  const char *load_path_suffix;
  size_t slen = strlen (load_path) + 10;
 
  load_path_suffix = strrchr (load_path, '/');
  if (NULL == load_path_suffix)
    load_path_suffix = load_path;
  else
    load_path_suffix++; /* skip '/' */
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Loading SQL resources from `%s'\n",
              load_path);
  for (unsigned int i = 1; i<10000; i++)
  {
    char patch_name[slen];
    enum GNUNET_DB_QueryStatus qs;
 
    /* Check with DB versioning schema if this patch was already applied,
       if so, skip it. */
    GNUNET_snprintf (patch_name,
                     sizeof (patch_name),
                     "%s%04u",
                     load_path_suffix,
                     i);
    {
      char *applied_by;
      struct GNUNET_PQ_QueryParam params[] = {
        GNUNET_PQ_query_param_string (patch_name),
        GNUNET_PQ_query_param_end
      };
      struct GNUNET_PQ_ResultSpec rs[] = {
        GNUNET_PQ_result_spec_string ("applied_by",
                                      &applied_by),
        GNUNET_PQ_result_spec_end
      };
 
      qs = GNUNET_PQ_eval_prepared_singleton_select (db,
                                                     "gnunet_pq_check_patch",
                                                     params,
                                                     rs);
      if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT == qs)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Database version %s already applied by %s, skipping\n",
                    patch_name,
                    applied_by);
        GNUNET_PQ_cleanup_result (rs);
      }
      if (GNUNET_DB_STATUS_HARD_ERROR == qs)
      {
        GNUNET_break (0);
        return GNUNET_SYSERR;
      }
    }
    if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT == qs)
      continue; /* patch already applied, skip it */
 
    if (0 != (GNUNET_PQ_FLAG_CHECK_CURRENT & db->flags))
    {
      /* We are only checking, found unapplied patch, bad! */
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Database outdated, patch %s missing. Aborting!\n",
                  patch_name);
      return GNUNET_SYSERR;
    }
    else
    {
      /* patch not yet applied, run it! */
      enum GNUNET_GenericReturnValue ret;
 
      GNUNET_snprintf (patch_name,
                       sizeof (patch_name),
                       "%s%04u",
                       load_path,
                       i);
      ret = GNUNET_PQ_exec_sql (db,
                                patch_name);
      if (GNUNET_NO == ret)
        break;
      if (GNUNET_SYSERR == ret)
        return GNUNET_SYSERR;
    }
  }
  return GNUNET_OK;
}

Referenced by GNUNET_PQ_reconnect().

Here is the caller graph for this function:

GNUNET_PQ_disconnect()

void GNUNET_PQ_disconnect

(

struct GNUNET_PQ_Context *

db

)

Disconnect from the database, destroying the prepared statements and releasing other associated resources.

Parameters

db	database handle to disconnect (will be free'd)

Definition at line 684 of file pq_connect.c.

{
  if (NULL == db)
    return;
  GNUNET_assert (0 ==
                 GNUNET_CONTAINER_multishortmap_size (db->channel_map));
  GNUNET_CONTAINER_multishortmap_destroy (db->channel_map);
  GNUNET_free (db->es);
  GNUNET_free (db->ps);
  GNUNET_free (db->load_path);
  GNUNET_free (db->auto_suffix);
  GNUNET_free (db->config_str);
  GNUNET_free (db->oids.table);
  db->oids.table = NULL;
  db->oids.num = 0;
  db->oids.cap = 0;
  PQfinish (db->conn);
  GNUNET_free (db);
}

References db, GNUNET_assert, GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_CONTAINER_multishortmap_size(), and GNUNET_free.

Referenced by database_shutdown(), libgnunet_plugin_datacache_postgres_done(), and libgnunet_plugin_datastore_postgres_done().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

ndim

uint32_t ndim

Definition at line 0 of file gnunet_pq_lib.h.

has_null

uint32_t has_null

Definition at line 1 of file gnunet_pq_lib.h.

oid

uint32_t oid

Definition at line 2 of file gnunet_pq_lib.h.

dim

uint32_t dim

Definition at line 3 of file gnunet_pq_lib.h.

Referenced by cores_send_disconnect_info(), and handle_disconnect().

lbound

uint32_t lbound

Definition at line 4 of file gnunet_pq_lib.h.

__attribute__

struct PrismHeader __attribute__