pq_result_helper.c File Reference

functions to extract result values More...

#include "platform.h"
#include "gnunet_time_lib.h"
#include "gnunet_common.h"
#include "gnunet_util_lib.h"
#include "gnunet_pq_lib.h"
#include "pq.h"

Include dependency graph for pq_result_helper.c:

Go to the source code of this file.

Data Structures
struct	array_result_cls
	Closure for the array result specifications. More...

Macros
#define	FAIL_IF(cond)

Functions
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...
static void	clean_varsize_blob (void *cls, void *rd)
	Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter. More...
static enum GNUNET_GenericReturnValue	extract_varsize_blob (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...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_variable_size (const char *name, void **dst, size_t *sptr)
	Variable-size result expected. More...
static enum GNUNET_GenericReturnValue	extract_fixed_blob (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...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_fixed_size (const char *name, void *dst, size_t dst_size)
	Fixed-size result expected. More...
static enum GNUNET_GenericReturnValue	extract_rsa_public_key (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...
static void	clean_rsa_public_key (void *cls, void *rd)
	Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter. 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...
static enum GNUNET_GenericReturnValue	extract_rsa_signature (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...
static void	clean_rsa_signature (void *cls, void *rd)
	Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_rsa_signature (const char *name, struct GNUNET_CRYPTO_RsaSignature **sig)
	RSA signature expected. More...
static enum GNUNET_GenericReturnValue	extract_string (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...
static void	clean_string (void *cls, void *rd)
	Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_string (const char *name, char **dst)
	0-terminated string expected. More...
static enum GNUNET_GenericReturnValue	extract_bool (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...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_bool (const char *name, bool *dst)
	boolean expected. More...
static enum GNUNET_GenericReturnValue	extract_rel_time (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...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_relative_time (const char *name, struct GNUNET_TIME_Relative *rt)
	Relative time expected. More...
static enum GNUNET_GenericReturnValue	extract_abs_time (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...
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_absolute_time_nbo (const char *name, struct GNUNET_TIME_AbsoluteNBO *at)
	Absolute time expected. More...
static enum GNUNET_GenericReturnValue	extract_timestamp (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...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_timestamp (const char *name, struct GNUNET_TIME_Timestamp *at)
	Timestamp expected. More...
static enum GNUNET_GenericReturnValue	extract_timestamp_nbo (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...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_timestamp_nbo (const char *name, struct GNUNET_TIME_TimestampNBO *at)
	Timestamp expected. More...
static enum GNUNET_GenericReturnValue	extract_uint16 (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...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_uint16 (const char *name, uint16_t *u16)
	uint16_t expected. More...
static enum GNUNET_GenericReturnValue	extract_uint32 (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...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_uint32 (const char *name, uint32_t *u32)
	uint32_t expected. More...
static enum GNUNET_GenericReturnValue	extract_uint64 (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...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_uint64 (const char *name, uint64_t *u64)
	uint64_t expected. More...
static enum GNUNET_GenericReturnValue	extract_int64 (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...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_int64 (const char *name, int64_t *i64)
	int64_t expected. More...
static enum GNUNET_GenericReturnValue	extract_array_generic (void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)
	Extract data from a Postgres database result as array of a specific type from row row. More...
static void	array_cleanup (void *cls, void *rd)
	Cleanup of the data and closure of an array spec. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_array_bool (struct GNUNET_PQ_Context *db, const char *name, size_t *num, bool **dst)
	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...
static enum GNUNET_GenericReturnValue	extract_blind_sign_pub (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...
static void	clean_blind_sign_pub (void *cls, void *rd)
	Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_blind_sign_pub (const char *name, struct GNUNET_CRYPTO_BlindSignPublicKey **pub)
	Blind sign public key expected. More...
static enum GNUNET_GenericReturnValue	extract_blind_sign_priv (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...
static void	clean_blind_sign_priv (void *cls, void *rd)
	Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter. More...
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_blind_sign_priv (const char *name, struct GNUNET_CRYPTO_BlindSignPrivateKey **priv)
	Blind sign private key expected. More...

Detailed Description

functions to extract result values

Author

Christian Grothoff

Özgür Kesim

Definition in file pq_result_helper.c.

Macro Definition Documentation

FAIL_IF

#define FAIL_IF

(

cond

)

Value:

          do { \
            if ((cond)) \
            { \
              GNUNET_break (! (cond)); \
              goto FAIL; \
            } \
          } while (0)

Function Documentation

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

clean_varsize_blob()

static void clean_varsize_blob ( void *  cls, void *  rd  )

static

Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.

Parameters

cls	closure
rd	result data to clean up

Definition at line 55 of file pq_result_helper.c.

{
  void **dst = rd;
 
  (void) cls;
  if (NULL != *dst)
  {
    GNUNET_free (*dst);
    *dst = NULL;
  }
}

References GNUNET_PQ_ResultSpec::cls, GNUNET_PQ_ResultSpec::dst, GNUNET_free, and rd.

Referenced by GNUNET_PQ_result_spec_variable_size().

Here is the caller graph for this function:

extract_varsize_blob()

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

static

Extract data from a Postgres database result at row row.

Parameters

	cls	closure
	result	where to extract data from
	row	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_SYSERR if a result was invalid (non-existing field)

Definition at line 83 of file pq_result_helper.c.

{
  size_t len;
  const char *res;
  void *idst;
  int fnum;
 
  (void) cls;
  *dst_size = 0;
  *((void **) dst) = NULL;
 
  fnum = PQfnumber (result,
                    fname);
  if (fnum < 0)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (PQgetisnull (result,
                   row,
                   fnum))
    return GNUNET_NO;
  /* if a field is null, continue but
   * remember that we now return a different result */
  len = PQgetlength (result,
                     row,
                     fnum);
  res = PQgetvalue (result,
                    row,
                    fnum);
  GNUNET_assert (NULL != res);
  *dst_size = len;
  idst = GNUNET_malloc (len);
  *((void **) dst) = idst;
  GNUNET_memcpy (idst,
                 res,
                 len);
  return GNUNET_OK;
}

References GNUNET_PQ_ResultSpec::cls, GNUNET_PQ_ResultSpec::dst, GNUNET_PQ_ResultSpec::dst_size, GNUNET_PQ_ResultSpec::fname, GNUNET_assert, GNUNET_break, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, res, and result.

Referenced by GNUNET_PQ_result_spec_variable_size().

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

References clean_varsize_blob(), GNUNET_PQ_ResultSpec::dst, extract_varsize_blob(), name, and res.

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

Here is the call graph for this function:

Here is the caller graph for this function:

extract_fixed_blob()

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

static

Extract data from a Postgres database result at row row.

Parameters

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

Returns

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

Definition at line 160 of file pq_result_helper.c.

{
  size_t len;
  const char *res;
  int fnum;
 
  (void) cls;
  fnum = PQfnumber (result,
                    fname);
  if (fnum < 0)
  {
    GNUNET_break (0);
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Result does not have field %s\n",
                fname);
    return GNUNET_SYSERR;
  }
  if (PQgetisnull (result,
                   row,
                   fnum))
    return GNUNET_NO;
  /* if a field is null, continue but
   * remember that we now return a different result */
  len = PQgetlength (result,
                     row,
                     fnum);
  if (*dst_size != len)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Expected %u bytes for field `%s', got %u\n",
                (unsigned int) *dst_size,
                fname,
                (unsigned int) len);
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  res = PQgetvalue (result,
                    row,
                    fnum);
  GNUNET_assert (NULL != res);
  GNUNET_memcpy (dst,
                 res,
                 len);
  return GNUNET_OK;
}

References GNUNET_PQ_ResultSpec::cls, GNUNET_PQ_ResultSpec::dst, GNUNET_PQ_ResultSpec::dst_size, GNUNET_PQ_ResultSpec::fname, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, res, and result.

Referenced by GNUNET_PQ_result_spec_fixed_size().

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

References GNUNET_PQ_ResultSpec::dst, GNUNET_PQ_ResultSpec::dst_size, extract_fixed_blob(), GNUNET_PQ_ResultSpec::fname, name, and res.

Here is the call graph for this function:

extract_rsa_public_key()

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

static

Extract data from a Postgres database result at row row.

Parameters

	cls	closure
	result	where to extract data from
	row	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_SYSERR if a result was invalid (non-existing field or NULL)

Definition at line 242 of file pq_result_helper.c.

{
  struct GNUNET_CRYPTO_RsaPublicKey **pk = dst;
  size_t len;
  const char *res;
  int fnum;
 
  (void) cls;
  *pk = NULL;
  fnum = PQfnumber (result,
                    fname);
  if (fnum < 0)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (PQgetisnull (result,
                   row,
                   fnum))
    return GNUNET_NO;
 
  /* if a field is null, continue but
   * remember that we now return a different result */
  len = PQgetlength (result,
                     row,
                     fnum);
  res = PQgetvalue (result,
                    row,
                    fnum);
  *pk = GNUNET_CRYPTO_rsa_public_key_decode (res,
                                             len);
  if (NULL == *pk)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_CRYPTO_rsa_public_key_decode(), GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, pk, res, and result.

Referenced by GNUNET_PQ_result_spec_rsa_public_key().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_rsa_public_key()

static void clean_rsa_public_key ( void *  cls, void *  rd  )

static

Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.

Parameters

cls	closure
rd	result data to clean up

Definition at line 295 of file pq_result_helper.c.

{
  struct GNUNET_CRYPTO_RsaPublicKey **pk = rd;
 
  (void) cls;
  if (NULL != *pk)
  {
    GNUNET_CRYPTO_rsa_public_key_free (*pk);
    *pk = NULL;
  }
}

References GNUNET_CRYPTO_rsa_public_key_free(), pk, and rd.

Referenced by GNUNET_PQ_result_spec_rsa_public_key().

Here is the call graph for this function:

Here is the caller graph for this function:

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

References clean_rsa_public_key(), extract_rsa_public_key(), GNUNET_PQ_ResultSpec::fname, name, and res.

Here is the call graph for this function:

extract_rsa_signature()

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

static

Extract data from a Postgres database result at row row.

Parameters

	cls	closure
	result	where to extract data from
	row	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_SYSERR if a result was invalid (non-existing field or NULL)

Definition at line 338 of file pq_result_helper.c.

{
  struct GNUNET_CRYPTO_RsaSignature **sig = dst;
  size_t len;
  const void *res;
  int fnum;
 
  (void) cls;
  *sig = NULL;
  fnum = PQfnumber (result,
                    fname);
  if (fnum < 0)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (PQgetisnull (result,
                   row,
                   fnum))
    return GNUNET_NO;
  /* if a field is null, continue but
   * remember that we now return a different result */
  len = PQgetlength (result,
                     row,
                     fnum);
  res = PQgetvalue (result,
                    row,
                    fnum);
  *sig = GNUNET_CRYPTO_rsa_signature_decode (res,
                                             len);
  if (NULL == *sig)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_CRYPTO_rsa_signature_decode(), GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, res, and result.

Referenced by GNUNET_PQ_result_spec_rsa_signature().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_rsa_signature()

static void clean_rsa_signature ( void *  cls, void *  rd  )

static

Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.

Parameters

cls	closure
rd	result data to clean up

Definition at line 390 of file pq_result_helper.c.

{
  struct GNUNET_CRYPTO_RsaSignature **sig = rd;
 
  (void) cls;
  if (NULL != *sig)
  {
    GNUNET_CRYPTO_rsa_signature_free (*sig);
    *sig = NULL;
  }
}

References GNUNET_CRYPTO_rsa_signature_free(), and rd.

Referenced by GNUNET_PQ_result_spec_rsa_signature().

Here is the call graph for this function:

Here is the caller graph for this function:

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

References clean_rsa_signature(), extract_rsa_signature(), GNUNET_PQ_ResultSpec::fname, name, and res.

Here is the call graph for this function:

extract_string()

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

static

Extract data from a Postgres database result at row row.

Parameters

	cls	closure
	result	where to extract data from
	row	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_SYSERR if a result was invalid (non-existing field or NULL)

Definition at line 433 of file pq_result_helper.c.

{
  char **str = dst;
  size_t len;
  const char *res;
  int fnum;
 
  (void) cls;
  *str = NULL;
  fnum = PQfnumber (result,
                    fname);
  if (fnum < 0)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (PQgetisnull (result,
                   row,
                   fnum))
    return GNUNET_NO;
  /* if a field is null, continue but
   * remember that we now return a different result */
  len = PQgetlength (result,
                     row,
                     fnum);
  res = PQgetvalue (result,
                    row,
                    fnum);
  *str = GNUNET_strndup (res,
                         len);
  if (NULL == *str)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_PQ_ResultSpec::cls, GNUNET_PQ_ResultSpec::dst, GNUNET_PQ_ResultSpec::fname, GNUNET_break, GNUNET_NO, GNUNET_OK, GNUNET_strndup, GNUNET_SYSERR, res, and result.

Referenced by GNUNET_PQ_result_spec_string().

Here is the caller graph for this function:

clean_string()

static void clean_string ( void *  cls, void *  rd  )

static

Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.

Parameters

cls	closure
rd	result data to clean up

Definition at line 485 of file pq_result_helper.c.

{
  char **str = rd;
 
  (void) cls;
  if (NULL != *str)
  {
    GNUNET_free (*str);
    *str = NULL;
  }
}

References GNUNET_PQ_ResultSpec::cls, GNUNET_free, and rd.

Referenced by GNUNET_PQ_result_spec_string().

Here is the caller graph for this function:

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 500 of file pq_result_helper.c.

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

References clean_string(), GNUNET_PQ_ResultSpec::dst, extract_string(), GNUNET_PQ_ResultSpec::fname, name, and res.

Referenced by check_patch_applied(), and parse_result_call_iterator().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_bool()

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

static

Extract data from a Postgres database result at row row.

Parameters

	cls	closure
	result	where to extract data from
	row	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_SYSERR if a result was invalid (non-existing field or NULL)

Definition at line 528 of file pq_result_helper.c.

{
  bool *b = dst;
  const uint8_t *res;
  int fnum;
  size_t len;
 
  (void) cls;
  fnum = PQfnumber (result,
                    fname);
  if (fnum < 0)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (PQgetisnull (result,
                   row,
                   fnum))
    return GNUNET_NO;
  /* if a field is null, continue but
   * remember that we now return a different result */
  len = PQgetlength (result,
                     row,
                     fnum);
  if (sizeof (uint8_t) != len)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  res = (const uint8_t *) PQgetvalue (result,
                                      row,
                                      fnum);
  *b = (0 != *res);
  return GNUNET_OK;
}

References GNUNET_PQ_ResultSpec::cls, GNUNET_PQ_ResultSpec::dst, GNUNET_PQ_ResultSpec::fname, GNUNET_break, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, res, and result.

Referenced by GNUNET_PQ_result_spec_bool().

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 571 of file pq_result_helper.c.

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

References GNUNET_PQ_ResultSpec::dst, extract_bool(), GNUNET_PQ_ResultSpec::fname, name, and res.

Here is the call graph for this function:

extract_rel_time()

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

static

Extract data from a Postgres database result at row row.

Parameters

	cls	closure
	result	where to extract data from
	row	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_SYSERR if a result was invalid (non-existing field or NULL)

Definition at line 598 of file pq_result_helper.c.

{
  struct GNUNET_TIME_Relative *udst = dst;
  const int64_t *res;
  int fnum;
 
  (void) cls;
  fnum = PQfnumber (result,
                    fname);
  if (fnum < 0)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (PQgetisnull (result,
                   row,
                   fnum))
    return GNUNET_NO;
  GNUNET_assert (NULL != dst);
  if (sizeof(struct GNUNET_TIME_Relative) != *dst_size)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (sizeof(int64_t) !=
      PQgetlength (result,
                   row,
                   fnum))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  res = (int64_t *) PQgetvalue (result,
                                row,
                                fnum);
  if (INT64_MAX == GNUNET_ntohll ((uint64_t) *res))
    *udst = GNUNET_TIME_UNIT_FOREVER_REL;
  else
    udst->rel_value_us = GNUNET_ntohll ((uint64_t) *res);
  return GNUNET_OK;
}

References GNUNET_assert, GNUNET_break, GNUNET_NO, GNUNET_ntohll(), GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_Relative::rel_value_us, res, and result.

Referenced by GNUNET_PQ_result_spec_relative_time().

Here is the call graph for this function:

Here is the caller graph for this function:

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

References GNUNET_PQ_ResultSpec::dst_size, extract_rel_time(), name, and res.

Here is the call graph for this function:

extract_abs_time()

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

static

Extract data from a Postgres database result at row row.

Parameters

	cls	closure
	result	where to extract data from
	row	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_SYSERR if a result was invalid (non-existing field or NULL)

Definition at line 675 of file pq_result_helper.c.

{
  struct GNUNET_TIME_Absolute *udst = dst;
  const int64_t *res;
  int fnum;
 
  (void) cls;
  fnum = PQfnumber (result,
                    fname);
  if (fnum < 0)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (PQgetisnull (result,
                   row,
                   fnum))
    return GNUNET_NO;
  GNUNET_assert (NULL != dst);
  if (sizeof(struct GNUNET_TIME_Absolute) != *dst_size)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (sizeof(int64_t) !=
      PQgetlength (result,
                   row,
                   fnum))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  res = (int64_t *) PQgetvalue (result,
                                row,
                                fnum);
  if (INT64_MAX == GNUNET_ntohll ((uint64_t) *res))
    *udst = GNUNET_TIME_UNIT_FOREVER_ABS;
  else
    udst->abs_value_us = GNUNET_ntohll ((uint64_t) *res);
  return GNUNET_OK;
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_assert, GNUNET_break, GNUNET_NO, GNUNET_ntohll(), GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_ABS, res, and result.

Referenced by GNUNET_PQ_result_spec_absolute_time().

Here is the call graph for this function:

Here is the caller graph for this function:

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

References GNUNET_PQ_ResultSpec::dst_size, extract_abs_time(), name, and res.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

References GNUNET_PQ_result_spec_auto_from_type, name, and res.

extract_timestamp()

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

static

Extract data from a Postgres database result at row row.

Parameters

	cls	closure
	result	where to extract data from
	row	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_SYSERR if a result was invalid (non-existing field or NULL)

Definition at line 764 of file pq_result_helper.c.

{
  struct GNUNET_TIME_Timestamp *udst = dst;
  struct GNUNET_TIME_Absolute abs;
  const int64_t *res;
  int fnum;
 
  (void) cls;
  fnum = PQfnumber (result,
                    fname);
  if (fnum < 0)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (PQgetisnull (result,
                   row,
                   fnum))
    return GNUNET_NO;
  GNUNET_assert (NULL != dst);
  if (sizeof(struct GNUNET_TIME_Absolute) != *dst_size)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (sizeof(int64_t) !=
      PQgetlength (result,
                   row,
                   fnum))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  res = (int64_t *) PQgetvalue (result,
                                row,
                                fnum);
  if (INT64_MAX == GNUNET_ntohll ((uint64_t) *res))
  {
    abs = GNUNET_TIME_UNIT_FOREVER_ABS;
  }
  else
  {
    abs.abs_value_us = GNUNET_ntohll ((uint64_t) *res);
    if (0 != abs.abs_value_us % GNUNET_TIME_UNIT_SECONDS.rel_value_us)
    {
      /* timestamps must be multiple of seconds! */
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
  }
  udst->abs_time = abs;
  return GNUNET_OK;
}

References GNUNET_TIME_Timestamp::abs_time, GNUNET_TIME_Absolute::abs_value_us, GNUNET_assert, GNUNET_break, GNUNET_NO, GNUNET_ntohll(), GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_SECONDS, res, and result.

Referenced by extract_timestamp_nbo(), and GNUNET_PQ_result_spec_timestamp().

Here is the call graph for this function:

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

References GNUNET_PQ_ResultSpec::dst_size, extract_timestamp(), name, and res.

Here is the call graph for this function:

extract_timestamp_nbo()

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

static

Extract data from a Postgres database result at row row.

Parameters

	cls	closure
	result	where to extract data from
	row	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_SYSERR if a result was invalid (non-existing field or NULL)

Definition at line 853 of file pq_result_helper.c.

{
  struct GNUNET_TIME_TimestampNBO *udst = dst;
  struct GNUNET_TIME_Timestamp t;
  enum GNUNET_GenericReturnValue r;
 
  r = extract_timestamp (NULL,
                         result,
                         row,
                         fname,
                         dst_size,
                         &t);
  if (GNUNET_OK != r)
    return r;
  *udst = GNUNET_TIME_timestamp_hton (t);
  return r;
}

References extract_timestamp(), GNUNET_OK, GNUNET_TIME_timestamp_hton(), result, and t.

Referenced by GNUNET_PQ_result_spec_timestamp_nbo().

Here is the call graph for this function:

Here is the caller graph for this function:

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

References GNUNET_PQ_ResultSpec::dst_size, extract_timestamp_nbo(), name, and res.

Here is the call graph for this function:

extract_uint16()

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

static

Extract data from a Postgres database result at row row.

Parameters

	cls	closure
	result	where to extract data from
	row	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_SYSERR if a result was invalid (non-existing field or NULL)

Definition at line 906 of file pq_result_helper.c.

{
  uint16_t *udst = dst;
  const uint16_t *res;
  int fnum;
 
  (void) cls;
  fnum = PQfnumber (result,
                    fname);
  if (fnum < 0)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (PQgetisnull (result,
                   row,
                   fnum))
    return GNUNET_NO;
  GNUNET_assert (NULL != dst);
  if (sizeof(uint16_t) != *dst_size)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (sizeof(uint16_t) !=
      PQgetlength (result,
                   row,
                   fnum))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  res = (uint16_t *) PQgetvalue (result,
                                 row,
                                 fnum);
  *udst = ntohs (*res);
  return GNUNET_OK;
}

References GNUNET_PQ_ResultSpec::cls, GNUNET_PQ_ResultSpec::dst, GNUNET_PQ_ResultSpec::dst_size, GNUNET_PQ_ResultSpec::fname, GNUNET_assert, GNUNET_break, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, res, and result.

Referenced by GNUNET_PQ_result_spec_uint16().

Here is the caller graph for this function:

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

References GNUNET_PQ_ResultSpec::dst_size, extract_uint16(), name, and res.

Here is the call graph for this function:

extract_uint32()

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

static

Extract data from a Postgres database result at row row.

Parameters

	cls	closure
	result	where to extract data from
	row	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_SYSERR if a result was invalid (non-existing field or NULL)

Definition at line 980 of file pq_result_helper.c.

{
  uint32_t *udst = dst;
  const uint32_t *res;
  int fnum;
 
  (void) cls;
  fnum = PQfnumber (result,
                    fname);
  if (fnum < 0)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (PQgetisnull (result,
                   row,
                   fnum))
    return GNUNET_NO;
  GNUNET_assert (NULL != dst);
  if (sizeof(uint32_t) != *dst_size)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (sizeof(uint32_t) !=
      PQgetlength (result,
                   row,
                   fnum))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  res = (uint32_t *) PQgetvalue (result,
                                 row,
                                 fnum);
  *udst = ntohl (*res);
  return GNUNET_OK;
}

References GNUNET_PQ_ResultSpec::cls, GNUNET_PQ_ResultSpec::dst, GNUNET_PQ_ResultSpec::dst_size, GNUNET_PQ_ResultSpec::fname, GNUNET_assert, GNUNET_break, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, res, and result.

Referenced by GNUNET_PQ_result_spec_uint32().

Here is the caller graph for this function:

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

References GNUNET_PQ_ResultSpec::dst_size, extract_uint32(), name, and res.

Referenced by extract_result_cb(), GNUNET_PQ_get_oid_by_name(), handle_results(), parse_result_call_iterator(), postgres_plugin_del(), and process_result().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_uint64()

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

static

Extract data from a Postgres database result at row row.

Parameters

	cls	closure
	result	where to extract data from
	row	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_SYSERR if a result was invalid (non-existing field or NULL)

Definition at line 1054 of file pq_result_helper.c.

{
  uint64_t *udst = dst;
  const uint64_t *res;
  int fnum;
 
  (void) cls;
  fnum = PQfnumber (result,
                    fname);
  if (fnum < 0)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Field %s missing in result\n",
                fname);
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (PQgetisnull (result,
                   row,
                   fnum))
    return GNUNET_NO;
 
  GNUNET_assert (NULL != dst);
  if (sizeof(uint64_t) != *dst_size)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (sizeof(uint64_t) !=
      PQgetlength (result,
                   row,
                   fnum))
  {
    GNUNET_break (0);
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Got length %u for field `%s'\n",
                PQgetlength (result,
                             row,
                             fnum),
                fname);
    return GNUNET_SYSERR;
  }
  res = (uint64_t *) PQgetvalue (result,
                                 row,
                                 fnum);
  *udst = GNUNET_ntohll (*res);
  return GNUNET_OK;
}

References GNUNET_PQ_ResultSpec::cls, GNUNET_PQ_ResultSpec::dst, GNUNET_PQ_ResultSpec::dst_size, GNUNET_PQ_ResultSpec::fname, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NO, GNUNET_ntohll(), GNUNET_OK, GNUNET_SYSERR, res, and result.

Referenced by GNUNET_PQ_result_spec_uint64().

Here is the call graph for this function:

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

References GNUNET_PQ_ResultSpec::dst_size, extract_uint64(), name, and res.

Referenced by parse_result_call_iterator(), postgres_plugin_del(), postgres_plugin_estimate_size(), and process_result().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_int64()

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

static

Extract data from a Postgres database result at row row.

Parameters

	cls	closure
	result	where to extract data from
	row	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_SYSERR if a result was invalid (non-existing field or NULL)

Definition at line 1138 of file pq_result_helper.c.

{
  int64_t *udst = dst;
  const int64_t *res;
  int fnum;
 
  (void) cls;
  fnum = PQfnumber (result,
                    fname);
  if (fnum < 0)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Field %s missing in result\n",
                fname);
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (PQgetisnull (result,
                   row,
                   fnum))
    return GNUNET_NO;
 
  GNUNET_assert (NULL != dst);
  if (sizeof(int64_t) != *dst_size)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (sizeof(int64_t) !=
      PQgetlength (result,
                   row,
                   fnum))
  {
    GNUNET_break (0);
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Got length %u for field `%s'\n",
                PQgetlength (result,
                             row,
                             fnum),
                fname);
    return GNUNET_SYSERR;
  }
  res = (int64_t *) PQgetvalue (result,
                                row,
                                fnum);
  *udst = GNUNET_ntohll (*res);
  return GNUNET_OK;
}

References GNUNET_PQ_ResultSpec::cls, GNUNET_PQ_ResultSpec::dst, GNUNET_PQ_ResultSpec::dst_size, GNUNET_PQ_ResultSpec::fname, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NO, GNUNET_ntohll(), GNUNET_OK, GNUNET_SYSERR, res, and result.

Referenced by GNUNET_PQ_result_spec_int64().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_result_spec_int64()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_int64	(	const char *	name,
		int64_t *	i64
	)

int64_t expected.

Parameters

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

Returns

array entry for the result specification to use

Definition at line 1194 of file pq_result_helper.c.

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

References GNUNET_PQ_ResultSpec::dst_size, extract_int64(), name, and res.

Here is the call graph for this function:

extract_array_generic()

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

static

Extract data from a Postgres database result as array of a specific type from row row.

The type information and optionally additional out-parameters are given in cls which is of type array_result_cls.

Parameters

	cls	closure of type array_result_cls
	result	where to extract data from
	row	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_SYSERR if a result was invalid (non-existing field or NULL)

Definition at line 1248 of file pq_result_helper.c.

{
  const struct array_result_cls *info = cls;
  int data_sz;
  char *data;
  void *out = NULL;
  struct pq_array_header header;
  int col_num;
 
  GNUNET_assert (NULL != dst);
  *((void **) dst) = NULL;
 
  #define FAIL_IF(cond) \
          do { \
            if ((cond)) \
            { \
              GNUNET_break (! (cond)); \
              goto FAIL; \
            } \
          } while (0)
 
  col_num = PQfnumber (result, fname);
  FAIL_IF (0 > col_num);
 
  data_sz = PQgetlength (result, row, col_num);
  FAIL_IF (0 > data_sz);
  data = PQgetvalue (result, row, col_num);
  if (sizeof(header) > (size_t) data_sz)
  {
    uint32_t ndim;
 
    /* data_sz is shorter than header if the
       array length is 0, in which case ndim is 0! */
    FAIL_IF (sizeof(uint32_t) > (size_t) data_sz);
    memcpy (&ndim,
            data,
            sizeof (ndim));
    FAIL_IF (0 != ndim);
    *info->num = 0;
    return GNUNET_OK;
  }
  FAIL_IF (sizeof(header) > (size_t) data_sz);
  FAIL_IF (NULL == data);
 
  {
    struct pq_array_header *h =
      (struct pq_array_header *) data;
 
    header.ndim = ntohl (h->ndim);
    header.has_null = ntohl (h->has_null);
    header.oid = ntohl (h->oid);
    header.dim = ntohl (h->dim);
    header.lbound = ntohl (h->lbound);
 
    FAIL_IF (1 != header.ndim);
    FAIL_IF (INT_MAX <= header.dim);
    FAIL_IF (0 != header.has_null);
    FAIL_IF (1 != header.lbound);
    FAIL_IF (info->oid != header.oid);
  }
 
  if (NULL != info->num)
    *info->num = header.dim;
 
  {
    char *in = data + sizeof(header);
 
    switch (info->typ)
    {
    case array_of_bool:
      if (NULL != dst_size)
        *dst_size = sizeof(bool) * (header.dim);
      out = GNUNET_new_array (header.dim, bool);
      *((void **) dst) = out;
      for (uint32_t i = 0; i < header.dim; i++)
      {
        size_t sz =  ntohl (*(uint32_t *) in);
        FAIL_IF (sz != sizeof(bool));
        in += sizeof(uint32_t);
        *(bool *) out = *(bool *) in;
        in += sz;
        out += sz;
      }
      break;
 
    case array_of_uint16:
      if (NULL != dst_size)
        *dst_size = sizeof(uint16_t) * (header.dim);
      out = GNUNET_new_array (header.dim, uint16_t);
      *((void **) dst) = out;
      for (uint32_t i = 0; i < header.dim; i++)
      {
        size_t sz =  ntohl (*(uint32_t *) in);
        FAIL_IF (sz != sizeof(uint16_t));
        in += sizeof(uint32_t);
        *(uint16_t *) out = ntohs (*(uint16_t *) in);
        in += sz;
        out += sz;
      }
      break;
 
    case array_of_uint32:
      if (NULL != dst_size)
        *dst_size = sizeof(uint32_t) * (header.dim);
      out = GNUNET_new_array (header.dim, uint32_t);
      *((void **) dst) = out;
      for (uint32_t i = 0; i < header.dim; i++)
      {
        size_t sz =  ntohl (*(uint32_t *) in);
        FAIL_IF (sz != sizeof(uint32_t));
        in += sizeof(uint32_t);
        *(uint32_t *) out = ntohl (*(uint32_t *) in);
        in += sz;
        out += sz;
      }
      break;
 
    case array_of_uint64:
      if (NULL != dst_size)
        *dst_size = sizeof(uint64_t) * (header.dim);
      out = GNUNET_new_array (header.dim, uint64_t);
      *((void **) dst) = out;
      for (uint32_t i = 0; i < header.dim; i++)
      {
        size_t sz =  ntohl (*(uint32_t *) in);
        FAIL_IF (sz != sizeof(uint64_t));
        in += sizeof(uint32_t);
        *(uint64_t *) out = GNUNET_ntohll (*(uint64_t *) in);
        in += sz;
        out += sz;
      }
      break;
 
    case array_of_abs_time:
      if (NULL != dst_size)
        *dst_size = sizeof(struct GNUNET_TIME_Absolute) * (header.dim);
      out = GNUNET_new_array (header.dim, struct GNUNET_TIME_Absolute);
      *((void **) dst) = out;
      for (uint32_t i = 0; i < header.dim; i++)
      {
        size_t sz =  ntohl (*(uint32_t *) in);
        FAIL_IF (sz != sizeof(uint64_t));
        in += sizeof(uint32_t);
        ((struct GNUNET_TIME_Absolute *) out)->abs_value_us =
          GNUNET_ntohll (*(uint64_t *) in);
        in += sz;
        out += sz;
      }
      break;
 
    case array_of_rel_time:
      if (NULL != dst_size)
        *dst_size = sizeof(struct GNUNET_TIME_Relative) * (header.dim);
      out = GNUNET_new_array (header.dim,
                              struct GNUNET_TIME_Relative);
      *((void **) dst) = out;
      for (uint32_t i = 0; i < header.dim; i++)
      {
        size_t sz =  ntohl (*(uint32_t *) in);
        FAIL_IF (sz != sizeof(uint64_t));
        in += sizeof(uint32_t);
        ((struct GNUNET_TIME_Relative *) out)->rel_value_us =
          GNUNET_ntohll (*(uint64_t *) in);
        in += sz;
        out += sz;
      }
      break;
 
    case array_of_timestamp:
      if (NULL != dst_size)
        *dst_size = sizeof(struct GNUNET_TIME_Timestamp) * (header.dim);
      out = GNUNET_new_array (header.dim,
                              struct GNUNET_TIME_Timestamp);
      *((void **) dst) = out;
      for (uint32_t i = 0; i < header.dim; i++)
      {
        size_t sz =  ntohl (*(uint32_t *) in);
        FAIL_IF (sz != sizeof(uint64_t));
        in += sizeof(uint32_t);
        ((struct GNUNET_TIME_Timestamp *) out)->abs_time.abs_value_us =
          GNUNET_ntohll (*(uint64_t *) in);
        in += sz;
        out += sz;
      }
      break;
 
    case array_of_byte:
      if (0 == info->same_size)
        *info->sizes = GNUNET_new_array (header.dim, size_t);
    /* fallthrough */
    case array_of_string:
      {
        size_t total = 0;
        bool is_string = (array_of_string == info->typ);
 
        /* first, calculate total size required for allocation */
        {
          char *ptr = data + sizeof(header);
          for (uint32_t i = 0; i < header.dim; i++)
          {
            uint32_t sz;
 
            sz = ntohl (*(uint32_t *) ptr);
            total += sz + (is_string ? 1 : 0);
            ptr += sizeof(uint32_t);
            ptr += sz;
 
            if ((! is_string) &&
                (0 == info->same_size))
              (*info->sizes)[i] = sz;
 
            FAIL_IF ((0 != info->same_size) &&
                     (sz != info->same_size));
            FAIL_IF (total < sz);
          }
        }
 
        if (NULL != dst_size)
          *dst_size = total;
 
        FAIL_IF (0 == total);
        out = GNUNET_malloc (total);
 
        *((void **) dst) = out;
 
        /* copy data */
        for (uint32_t i = 0; i < header.dim; i++)
        {
          size_t sz =  ntohl (*(uint32_t *) in);
          in += sizeof(uint32_t);
          GNUNET_memcpy (out, in, sz);
 
          in += sz;
          out += sz;
          out += (array_of_string == info->typ) ? 1 : 0;
        }
        break;
      }
    default:
      FAIL_IF (1 != 0);
    }
  }
 
  return GNUNET_OK;
 
FAIL:
  GNUNET_free (*(void **) dst);
  return GNUNET_SYSERR;
  #undef FAIL_IF
}

References 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, pq_array_header::dim, FAIL, FAIL_IF, GNUNET_assert, GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_new_array, GNUNET_ntohll(), GNUNET_OK, GNUNET_SYSERR, h, pq_array_header::has_null, info, INT_MAX, pq_array_header::lbound, ndim, pq_array_header::ndim, pq_array_header::oid, and result.

Referenced by GNUNET_PQ_result_spec_array_abs_time(), GNUNET_PQ_result_spec_array_bool(), GNUNET_PQ_result_spec_array_fixed_size(), GNUNET_PQ_result_spec_array_rel_time(), GNUNET_PQ_result_spec_array_string(), GNUNET_PQ_result_spec_array_timestamp(), GNUNET_PQ_result_spec_array_uint16(), GNUNET_PQ_result_spec_array_uint32(), GNUNET_PQ_result_spec_array_uint64(), and GNUNET_PQ_result_spec_array_variable_size().

Here is the call graph for this function:

Here is the caller graph for this function:

array_cleanup()

static void array_cleanup ( void *  cls, void *  rd  )

static

Cleanup of the data and closure of an array spec.

Definition at line 1510 of file pq_result_helper.c.

{
 
  struct array_result_cls *info = cls;
  void **dst = rd;
 
  if ((array_of_byte == info->typ) &&
      (0 == info->same_size) &&
      (NULL != info->sizes))
    GNUNET_free (*(info->sizes));
 
  GNUNET_free (cls);
  GNUNET_free (*dst);
  *dst = NULL;
}

References array_of_byte, GNUNET_free, info, and rd.

Referenced by GNUNET_PQ_result_spec_array_abs_time(), GNUNET_PQ_result_spec_array_bool(), GNUNET_PQ_result_spec_array_fixed_size(), GNUNET_PQ_result_spec_array_rel_time(), GNUNET_PQ_result_spec_array_string(), GNUNET_PQ_result_spec_array_timestamp(), GNUNET_PQ_result_spec_array_uint16(), GNUNET_PQ_result_spec_array_uint32(), GNUNET_PQ_result_spec_array_uint64(), and GNUNET_PQ_result_spec_array_variable_size().

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

References array_cleanup(), array_of_bool, GNUNET_PQ_ResultSpec::cls, db, GNUNET_PQ_ResultSpec::dst, extract_array_generic(), GNUNET_PQ_ResultSpec::fname, GNUNET_assert, GNUNET_new, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), info, name, array_result_cls::num, and res.

Here is the call graph for this function:

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

References array_cleanup(), array_of_uint16, GNUNET_PQ_ResultSpec::cls, db, GNUNET_PQ_ResultSpec::dst, extract_array_generic(), GNUNET_PQ_ResultSpec::fname, GNUNET_assert, GNUNET_new, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), info, name, array_result_cls::num, and res.

Here is the call graph for this function:

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

References array_cleanup(), array_of_uint32, GNUNET_PQ_ResultSpec::cls, db, GNUNET_PQ_ResultSpec::dst, extract_array_generic(), GNUNET_PQ_ResultSpec::fname, GNUNET_assert, GNUNET_new, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), info, name, array_result_cls::num, and res.

Here is the call graph for this function:

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

References array_cleanup(), array_of_uint64, GNUNET_PQ_ResultSpec::cls, db, GNUNET_PQ_ResultSpec::dst, extract_array_generic(), GNUNET_PQ_ResultSpec::fname, GNUNET_assert, GNUNET_new, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), info, name, array_result_cls::num, and res.

Here is the call graph for this function:

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

References array_cleanup(), array_of_abs_time, GNUNET_PQ_ResultSpec::cls, db, GNUNET_PQ_ResultSpec::dst, extract_array_generic(), GNUNET_PQ_ResultSpec::fname, GNUNET_assert, GNUNET_new, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), info, name, array_result_cls::num, and res.

Here is the call graph for this function:

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

References array_cleanup(), array_of_rel_time, GNUNET_PQ_ResultSpec::cls, db, GNUNET_PQ_ResultSpec::dst, extract_array_generic(), GNUNET_PQ_ResultSpec::fname, GNUNET_assert, GNUNET_new, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), info, name, array_result_cls::num, and res.

Here is the call graph for this function:

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

References array_cleanup(), array_of_timestamp, GNUNET_PQ_ResultSpec::cls, db, GNUNET_PQ_ResultSpec::dst, extract_array_generic(), GNUNET_PQ_ResultSpec::fname, GNUNET_assert, GNUNET_new, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), info, name, array_result_cls::num, and res.

Here is the call graph for this function:

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

References array_cleanup(), array_of_byte, GNUNET_PQ_ResultSpec::cls, db, GNUNET_PQ_ResultSpec::dst, extract_array_generic(), GNUNET_PQ_ResultSpec::fname, GNUNET_assert, GNUNET_new, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), info, name, array_result_cls::num, res, and array_result_cls::sizes.

Here is the call graph for this function:

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

References array_cleanup(), array_of_byte, GNUNET_PQ_ResultSpec::cls, db, GNUNET_PQ_ResultSpec::dst, extract_array_generic(), GNUNET_PQ_ResultSpec::fname, GNUNET_assert, GNUNET_new, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), info, name, array_result_cls::num, res, and size.

Here is the call graph for this function:

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 continuous array of num 0-terminated strings

Returns

array entry for the result specification to use

Definition at line 1799 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;
  }
}

References array_cleanup(), array_of_string, GNUNET_PQ_ResultSpec::cls, db, GNUNET_PQ_ResultSpec::dst, extract_array_generic(), GNUNET_PQ_ResultSpec::fname, GNUNET_assert, GNUNET_new, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), info, name, array_result_cls::num, and res.

Here is the call graph for this function:

extract_blind_sign_pub()

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

static

Extract data from a Postgres database result at row row.

Parameters

	cls	closure
	result	where to extract data from
	row	the 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_SYSERR if a result was invalid (non-existing field or NULL)

Definition at line 1842 of file pq_result_helper.c.

{
  struct GNUNET_CRYPTO_BlindSignPublicKey **bpk = dst;
  struct GNUNET_CRYPTO_BlindSignPublicKey *tmp;
  size_t len;
  const char *res;
  int fnum;
  uint32_t be;
 
  (void) cls;
  (void) dst_size;
  fnum = PQfnumber (result,
                    fname);
  if (fnum < 0)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (PQgetisnull (result,
                   row,
                   fnum))
    return GNUNET_NO;
 
  /* if a field is null, continue but
   * remember that we now return a different result */
  len = PQgetlength (result,
                     row,
                     fnum);
  res = PQgetvalue (result,
                    row,
                    fnum);
  if (len < sizeof (be))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  GNUNET_memcpy (&be,
                 res,
                 sizeof (be));
  res += sizeof (be);
  len -= sizeof (be);
  tmp = GNUNET_new (struct GNUNET_CRYPTO_BlindSignPublicKey);
  tmp->cipher = ntohl (be);
  tmp->rc = 1;
  switch (tmp->cipher)
  {
  case GNUNET_CRYPTO_BSA_INVALID:
    break;
  case GNUNET_CRYPTO_BSA_RSA:
    tmp->details.rsa_public_key
      = GNUNET_CRYPTO_rsa_public_key_decode (res,
                                             len);
    if (NULL == tmp->details.rsa_public_key)
    {
      GNUNET_break (0);
      GNUNET_free (tmp);
      return GNUNET_SYSERR;
    }
    GNUNET_CRYPTO_hash (res,
                        len,
                        &tmp->pub_key_hash);
    *bpk = tmp;
    return GNUNET_OK;
  case GNUNET_CRYPTO_BSA_CS:
    if (sizeof (tmp->details.cs_public_key) != len)
    {
      GNUNET_break (0);
      GNUNET_free (tmp);
      return GNUNET_SYSERR;
    }
    GNUNET_memcpy (&tmp->details.cs_public_key,
                   res,
                   len);
    GNUNET_CRYPTO_hash (res,
                        len,
                        &tmp->pub_key_hash);
    *bpk = tmp;
    return GNUNET_OK;
  }
  GNUNET_break (0);
  GNUNET_free (tmp);
  return GNUNET_SYSERR;
}

References GNUNET_CRYPTO_BlindSignPublicKey::cipher, GNUNET_CRYPTO_BlindSignPublicKey::cs_public_key, GNUNET_CRYPTO_BlindSignPublicKey::details, GNUNET_break, GNUNET_CRYPTO_BSA_CS, GNUNET_CRYPTO_BSA_INVALID, GNUNET_CRYPTO_BSA_RSA, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_rsa_public_key_decode(), GNUNET_free, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_CRYPTO_BlindSignPublicKey::pub_key_hash, GNUNET_CRYPTO_BlindSignPublicKey::rc, res, result, and GNUNET_CRYPTO_BlindSignPublicKey::rsa_public_key.

Referenced by GNUNET_PQ_result_spec_blind_sign_pub().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_blind_sign_pub()

static void clean_blind_sign_pub ( void *  cls, void *  rd  )

static

Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.

Parameters

cls	closure
rd	result data to clean up

Definition at line 1940 of file pq_result_helper.c.

{
  struct GNUNET_CRYPTO_BlindSignPublicKey **pub = rd;
 
  (void) cls;
  if (NULL != *pub)
  {
    GNUNET_CRYPTO_blind_sign_pub_decref (*pub);
    *pub = NULL;
  }
}

References GNUNET_CRYPTO_blind_sign_pub_decref(), pub, and rd.

Referenced by GNUNET_PQ_result_spec_blind_sign_pub().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_result_spec_blind_sign_pub()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_blind_sign_pub	(	const char *	name,
		struct GNUNET_CRYPTO_BlindSignPublicKey **	public_key
	)

Blind sign public key expected.

Parameters

	name	name of the field in the table
[out]	public_key	where to store the denomination signature

Returns

array entry for the result specification to use

Definition at line 1955 of file pq_result_helper.c.

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

References clean_blind_sign_pub(), extract_blind_sign_pub(), GNUNET_PQ_ResultSpec::fname, name, pub, and res.

Here is the call graph for this function:

extract_blind_sign_priv()

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

static

Extract data from a Postgres database result at row row.

Parameters

	cls	closure
	result	where to extract data from
	row	the 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_SYSERR if a result was invalid (non-existing field or NULL)

Definition at line 1984 of file pq_result_helper.c.

{
  struct GNUNET_CRYPTO_BlindSignPrivateKey **bpk = dst;
  struct GNUNET_CRYPTO_BlindSignPrivateKey *tmp;
  size_t len;
  const char *res;
  int fnum;
  uint32_t be;
 
  (void) cls;
  (void) dst_size;
  fnum = PQfnumber (result,
                    fname);
  if (fnum < 0)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (PQgetisnull (result,
                   row,
                   fnum))
    return GNUNET_NO;
 
  /* if a field is null, continue but
   * remember that we now return a different result */
  len = PQgetlength (result,
                     row,
                     fnum);
  res = PQgetvalue (result,
                    row,
                    fnum);
  if (len < sizeof (be))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  GNUNET_memcpy (&be,
                 res,
                 sizeof (be));
  res += sizeof (be);
  len -= sizeof (be);
  tmp = GNUNET_new (struct GNUNET_CRYPTO_BlindSignPrivateKey);
  tmp->cipher = ntohl (be);
  tmp->rc = 1;
  switch (tmp->cipher)
  {
  case GNUNET_CRYPTO_BSA_INVALID:
    break;
  case GNUNET_CRYPTO_BSA_RSA:
    tmp->details.rsa_private_key
      = GNUNET_CRYPTO_rsa_private_key_decode (res,
                                              len);
    if (NULL == tmp->details.rsa_private_key)
    {
      GNUNET_break (0);
      GNUNET_free (tmp);
      return GNUNET_SYSERR;
    }
    *bpk = tmp;
    return GNUNET_OK;
  case GNUNET_CRYPTO_BSA_CS:
    if (sizeof (tmp->details.cs_private_key) != len)
    {
      GNUNET_break (0);
      GNUNET_free (tmp);
      return GNUNET_SYSERR;
    }
    GNUNET_memcpy (&tmp->details.cs_private_key,
                   res,
                   len);
    *bpk = tmp;
    return GNUNET_OK;
  }
  GNUNET_break (0);
  GNUNET_free (tmp);
  return GNUNET_SYSERR;
}

References GNUNET_CRYPTO_BlindSignPrivateKey::cipher, GNUNET_CRYPTO_BlindSignPrivateKey::cs_private_key, GNUNET_CRYPTO_BlindSignPrivateKey::details, GNUNET_break, GNUNET_CRYPTO_BSA_CS, GNUNET_CRYPTO_BSA_INVALID, GNUNET_CRYPTO_BSA_RSA, GNUNET_CRYPTO_rsa_private_key_decode(), GNUNET_free, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_CRYPTO_BlindSignPrivateKey::rc, res, result, and GNUNET_CRYPTO_BlindSignPrivateKey::rsa_private_key.

Referenced by GNUNET_PQ_result_spec_blind_sign_priv().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_blind_sign_priv()

static void clean_blind_sign_priv ( void *  cls, void *  rd  )

static

Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.

Parameters

cls	closure
rd	result data to clean up

Definition at line 2076 of file pq_result_helper.c.

{
  struct GNUNET_CRYPTO_BlindSignPrivateKey **priv = rd;
 
  (void) cls;
  if (NULL != *priv)
  {
    GNUNET_CRYPTO_blind_sign_priv_decref (*priv);
    *priv = NULL;
  }
}

References GNUNET_CRYPTO_blind_sign_priv_decref(), and rd.

Referenced by GNUNET_PQ_result_spec_blind_sign_priv().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_result_spec_blind_sign_priv()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_blind_sign_priv	(	const char *	name,
		struct GNUNET_CRYPTO_BlindSignPrivateKey **	private_key
	)

Blind sign private key expected.

Parameters

	name	name of the field in the table
[out]	private_key	where to store the denomination signature

Returns

array entry for the result specification to use

Definition at line 2091 of file pq_result_helper.c.

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

References clean_blind_sign_priv(), extract_blind_sign_priv(), GNUNET_PQ_ResultSpec::fname, name, and res.

Here is the call graph for this function: