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)
#define	HANDLE_ELEMENT(typ, conv, access)
#define	HANDLE_ARRAY(typ, conv, access)
#define	DEREF(typ, conv)    *(typ *) out = conv (*(typ *) in)
#define	ACCESS_ABS(typ, conv)    ((typ *) out)->abs_value_us = conv (*(uint64_t *) in)
#define	ACCESS_REL(typ, conv)    ((typ *) out)->rel_value_us = conv (*(uint64_t *) in)
#define	ACCESS_TSTMP(typ, conv)    ((typ *) out)->abs_time.abs_value_us = conv (*(uint64_t *) in)

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.
static void	clean_varsize_blob (void *cls, void *rd)
	Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.
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.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_variable_size (const char *name, void **dst, size_t *sptr)
	Variable-size result expected.
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.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_fixed_size (const char *name, void *dst, size_t dst_size)
	Fixed-size result expected.
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.
static void	clean_rsa_public_key (void *cls, void *rd)
	Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_rsa_public_key (const char *name, struct GNUNET_CRYPTO_RsaPublicKey **rsa)
	RSA public key expected.
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.
static void	clean_rsa_signature (void *cls, void *rd)
	Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_rsa_signature (const char *name, struct GNUNET_CRYPTO_RsaSignature **sig)
	RSA signature expected.
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.
static void	clean_string (void *cls, void *rd)
	Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_string (const char *name, char **dst)
	0-terminated string expected.
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.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_bool (const char *name, bool *dst)
	boolean expected.
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.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_relative_time (const char *name, struct GNUNET_TIME_Relative *rt)
	Relative time expected.
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.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_absolute_time (const char *name, struct GNUNET_TIME_Absolute *at)
	Absolute time expected.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_absolute_time_nbo (const char *name, struct GNUNET_TIME_AbsoluteNBO *at)
	Absolute time expected.
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.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_timestamp (const char *name, struct GNUNET_TIME_Timestamp *at)
	Timestamp expected.
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.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_timestamp_nbo (const char *name, struct GNUNET_TIME_TimestampNBO *at)
	Timestamp expected.
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.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_uint16 (const char *name, uint16_t *u16)
	uint16_t expected.
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.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_uint32 (const char *name, uint32_t *u32)
	uint32_t expected.
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.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_uint64 (const char *name, uint64_t *u64)
	uint64_t expected.
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.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_int64 (const char *name, int64_t *i64)
	int64_t expected.
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.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_array_allow_nulls (struct GNUNET_PQ_ResultSpec rs, bool **is_nulls)
	Allow NULL values in an array to be found in the database for the given value.
static void	array_cleanup (void *cls, void *rd)
	Cleanup of the data and closure of an array spec.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
static void	clean_blind_sign_pub (void *cls, void *rd)
	Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_blind_sign_pub (const char *name, struct GNUNET_CRYPTO_BlindSignPublicKey **pub)
	Blind sign public key expected.
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.
static void	clean_blind_sign_priv (void *cls, void *rd)
	Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_blind_sign_priv (const char *name, struct GNUNET_CRYPTO_BlindSignPrivateKey **priv)
	Blind sign private key expected.
static enum GNUNET_GenericReturnValue	extract_blinded_sig (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.
static void	clean_blinded_sig (void *cls, void *rd)
	Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_blinded_sig (const char *name, struct GNUNET_CRYPTO_BlindedSignature **b_sig)
	Blinded signature expected.
static enum GNUNET_GenericReturnValue	extract_unblinded_sig (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.
static void	clean_unblinded_sig (void *cls, void *rd)
	Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.
struct GNUNET_PQ_ResultSpec	GNUNET_PQ_result_spec_unblinded_sig (const char *name, struct GNUNET_CRYPTO_UnblindedSignature **ub_sig)
	Unblinded signature expected.

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)

HANDLE_ELEMENT

#define HANDLE_ELEMENT	(		typ,
			conv,
			access
	)

Value:

        do { \
          int32_t sz =  ntohl (*(int32_t *) in); \
\
          in += sizeof(uint32_t); \
          if (-1 != sz) \
          { \
            FAIL_IF (sz != sizeof(typ)); \
            access (typ, conv); \
            in += sz; \
          } \
          else \
          { \
            FAIL_IF (! info->allow_nulls); \
            (*info->is_nulls)[i] = true; \
          } \
\
          out += sizeof(typ); \
        } while (0)

HANDLE_ARRAY

#define HANDLE_ARRAY	(		typ,
			conv,
			access
	)

Value:

        do { \
          if (NULL != dst_size) \
          *dst_size = sizeof(typ) *(header.dim); \
          out = GNUNET_new_array (header.dim, typ); \
          *((void **) dst) = out; \
          for (uint32_t i = 0; i < header.dim; i++) \
          { \
            HANDLE_ELEMENT (typ, conv, access); \
          } \
        } while (0)

DEREF

#define DEREF	(		typ,
			conv
	)		*(typ *) out = conv (*(typ *) in)

ACCESS_ABS

#define ACCESS_ABS	(		typ,
			conv
	)		((typ *) out)->abs_value_us = conv (*(uint64_t *) in)

ACCESS_REL

#define ACCESS_REL	(		typ,
			conv
	)		((typ *) out)->rel_value_us = conv (*(uint64_t *) in)

ACCESS_TSTMP

#define ACCESS_TSTMP	(		typ,
			conv
	)		((typ *) out)->abs_time.abs_value_us = conv (*(uint64_t *) in)

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 34 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 54 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 82 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 129 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::conv, 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 159 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 212 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::conv, 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 241 of file pq_result_helper.c.

{
  struct GNUNET_CRYPTO_RsaPublicKey **pk = dst;
  size_t len;
  const char *res;
  int fnum;
 
  (void) cls;
  (void) dst_size;
  *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(), GNUNET_PQ_ResultSpec::conv, 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;
  (void) dst_size;
  *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 391 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 406 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(), GNUNET_PQ_ResultSpec::conv, 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 434 of file pq_result_helper.c.

{
  char **str = dst;
  size_t len;
  const char *res;
  int fnum;
 
  (void) cls;
  (void) dst_size;
  *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::dst_size, GNUNET_PQ_ResultSpec::fname, GNUNET_break, GNUNET_NO, GNUNET_OK, GNUNET_strndup, GNUNET_SYSERR, res, result, and str.

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 487 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, rd, and str.

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 502 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::conv, 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 530 of file pq_result_helper.c.

{
  bool *b = dst;
  const uint8_t *res;
  int fnum;
  size_t len;
 
  (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);
  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::dst_size, 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 574 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::conv, 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 601 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 650 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::conv, 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 678 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 727 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::conv, 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 742 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 767 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 828 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::conv, 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 856 of file pq_result_helper.c.

{
  struct GNUNET_TIME_TimestampNBO *udst = dst;
  struct GNUNET_TIME_Timestamp t;
  enum GNUNET_GenericReturnValue r;
 
  (void) cls;
  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 882 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::conv, 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 910 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 956 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::conv, 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 984 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 1030 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::conv, 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 1058 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 1114 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::conv, 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 1142 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 1198 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::conv, 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)

The sizes of the elements in the input. A NULL element will be indicated in the input by a size of -1. However, we will then use an element size of either 0 (for variable sized data) or info->same_size (for fixed sized data).

The amounts of bytes to advance the in-pointer after the encoded size of an element. If the element is NULL (indicated by a size of -1), the value will be 0, independent of the corresponding value of elem_sz.

Definition at line 1260 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);
 
  /* Report if this field is empty */
  if (0 == (size_t) data_sz)
    return GNUNET_NO;
 
  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_nulls = ntohl (h->has_nulls);
    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_nulls) && ! info->allow_nulls);
    FAIL_IF (1 != header.lbound);
    FAIL_IF (info->oid != header.oid);
  }
 
  if (NULL != info->num)
    *info->num = header.dim;
 
  /* Prepare the array of bools, marking NULL elements */
  if (info->allow_nulls)
    *info->is_nulls = GNUNET_new_array (header.dim, bool);
 
  {
    char *in = data + sizeof(header);
 
#define HANDLE_ELEMENT(typ, conv, access) \
        do { \
          int32_t sz =  ntohl (*(int32_t *) in); \
\
          in += sizeof(uint32_t); \
          if (-1 != sz) \
          { \
            FAIL_IF (sz != sizeof(typ)); \
            access (typ, conv); \
            in += sz; \
          } \
          else \
          { \
            FAIL_IF (! info->allow_nulls); \
            (*info->is_nulls)[i] = true; \
          } \
\
          out += sizeof(typ); \
        } while (0)
 
#define HANDLE_ARRAY(typ, conv, access) \
        do { \
          if (NULL != dst_size) \
          *dst_size = sizeof(typ) *(header.dim); \
          out = GNUNET_new_array (header.dim, typ); \
          *((void **) dst) = out; \
          for (uint32_t i = 0; i < header.dim; i++) \
          { \
            HANDLE_ELEMENT (typ, conv, access); \
          } \
        } while (0)
 
#define DEREF(typ, conv) \
        *(typ *) out = conv (*(typ *) in)
 
#define ACCESS_ABS(typ, conv) \
        ((typ *) out)->abs_value_us = conv (*(uint64_t *) in)
 
#define ACCESS_REL(typ, conv) \
        ((typ *) out)->rel_value_us = conv (*(uint64_t *) in)
 
#define ACCESS_TSTMP(typ, conv) \
        ((typ *) out)->abs_time.abs_value_us = conv (*(uint64_t *) in)
 
    switch (info->typ)
    {
    case array_of_bool:
      HANDLE_ARRAY (bool, /* no conv */, DEREF);
      break;
    case array_of_uint16:
      HANDLE_ARRAY (uint16_t, ntohs, DEREF);
      break;
    case array_of_uint32:
      HANDLE_ARRAY (uint32_t, ntohl, DEREF);
      break;
    case array_of_uint64:
      HANDLE_ARRAY (uint64_t, GNUNET_ntohll, DEREF);
      break;
    case array_of_abs_time:
      HANDLE_ARRAY (struct GNUNET_TIME_Absolute,
                    GNUNET_ntohll,
                    ACCESS_ABS);
      break;
    case array_of_rel_time:
      HANDLE_ARRAY (struct GNUNET_TIME_Relative,
                    GNUNET_ntohll,
                    ACCESS_REL);
      break;
    case array_of_timestamp:
      HANDLE_ARRAY (struct GNUNET_TIME_Timestamp,
                    GNUNET_ntohll,
                    ACCESS_TSTMP);
      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_sz = 0;
        bool is_string = (array_of_string == info->typ);
        uint32_t elem_sz[header.dim];
        uint32_t in_adv[header.dim];
        bool is_null[header.dim];
 
        memset (elem_sz, 0, sizeof(elem_sz));
        memset (in_adv, 0, sizeof(in_adv));
        memset (is_null, 0, sizeof(is_null));
 
        /* first, calculate total size required for allocation */
        for (uint32_t i = 0; i < header.dim; i++)
        {
          int32_t sz = ntohl (*(int32_t *) in);
 
          if (-1 == sz) /* signifies NULL entry */
          {
            FAIL_IF (! info->allow_nulls);
            is_null[i] = true;
            elem_sz[i] =   info->same_size ? info->same_size : 0;
            in_adv[i] = 0;
          }
          else
          {
            FAIL_IF (0 > sz);
            elem_sz[i] = sz;
            in_adv[i] = sz;
          }
          FAIL_IF (info->same_size &&
                   (elem_sz[i] != info->same_size));
 
          if (info->allow_nulls)
            (*info->is_nulls)[i] = is_null[i];
 
          if ((! is_string) &&
              (! info->same_size))
            (*info->sizes)[i] = elem_sz[i];
 
          total_sz += elem_sz[i];
          /* add room for terminator for non-NULL entry of type string */
          total_sz += (is_string && ! is_null[i]) ? 1 : 0;
          in += sizeof(int32_t);
          in += in_adv[i];
 
          FAIL_IF (total_sz < elem_sz[i]);
        }
 
        FAIL_IF ((! info->allow_nulls) && (0 == total_sz));
        if (NULL != dst_size)
          *dst_size = total_sz;
 
        out = GNUNET_malloc (total_sz);
        *((void **) dst) = out;
        in = data + sizeof(header); /* reset to beginning of input */
 
        /* Finally, copy the data */
        for (uint32_t i = 0; i < header.dim; i++)
        {
          in += sizeof(uint32_t); /* skip length */
          if (! is_null[i])
            GNUNET_memcpy (out, in, elem_sz[i]);
 
          in += in_adv[i];
          out += elem_sz[i];
          out += (is_string && ! is_null[i]) ? 1 : 0;
        }
        break;
      }
    default:
      FAIL_IF (1 != 0);
    }
  }
 
  return GNUNET_OK;
 
FAIL:
  GNUNET_free (*(void **) dst);
  return GNUNET_SYSERR;
#undef FAIL_IF
#undef DEREF
#undef ACCESS_ABS
#undef ACCESS_REL
#undef ACCESS_TSTMP
#undef HANDLE_ARRAY
#undef HANDLE_ELEMENT
}

References ACCESS_ABS, ACCESS_REL, ACCESS_TSTMP, 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, DEREF, pq_array_header::dim, FAIL, FAIL_IF, GNUNET_assert, GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_new_array, GNUNET_NO, GNUNET_ntohll(), GNUNET_OK, GNUNET_SYSERR, h, HANDLE_ARRAY, pq_array_header::has_nulls, 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_allow_nulls(), 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:

GNUNET_PQ_result_spec_array_allow_nulls()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_allow_nulls	(	struct GNUNET_PQ_ResultSpec	rs,
		bool **	is_nulls
	)

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

Parameters

	rs	result spec entry to modify, MUST be one for the array types
[out]	is_nulls	location where to put the array of bools, whose elements will be set to 'true' if the value was indeed NULL, or to 'false' if the value was non-NULL. This parameter MUST NOT be NULL itself. The length of the allocated array will be equal to the length of the result for the values in rs.

Returns

array entry for the result specification to use

Definition at line 1523 of file pq_result_helper.c.

{
  struct GNUNET_PQ_ResultSpec rsr;
  struct array_result_cls *info = rs.cls;
 
  GNUNET_assert (rs.conv == extract_array_generic);
  GNUNET_assert (NULL != is_nulls);
  info->allow_nulls = true;
  info->is_nulls = is_nulls;
 
  rsr = rs;
  return rsr;
}

References extract_array_generic(), GNUNET_assert, info, and array_result_cls::is_nulls.

Here is the call 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 1544 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));
 
  if (info->allow_nulls)
    GNUNET_free (*info->is_nulls);
 
  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 1566 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, GNUNET_PQ_ResultSpec::conv, 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 1596 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, GNUNET_PQ_ResultSpec::conv, 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 1626 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, GNUNET_PQ_ResultSpec::conv, 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 1656 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, GNUNET_PQ_ResultSpec::conv, 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 1684 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, GNUNET_PQ_ResultSpec::conv, 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 1712 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, GNUNET_PQ_ResultSpec::conv, 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 1742 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, GNUNET_PQ_ResultSpec::conv, 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 of sizes given in size, allocated

Returns

array entry for the result specification to use

Definition at line 1772 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, GNUNET_PQ_ResultSpec::conv, 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 @num fixed-size elements

Returns

array entry for the result specification to use

Definition at line 1804 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, GNUNET_PQ_ResultSpec::conv, 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 1836 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, GNUNET_PQ_ResultSpec::conv, 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 1879 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 1977 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 1992 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(), GNUNET_PQ_ResultSpec::conv, 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 2021 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 2113 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 2128 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(), GNUNET_PQ_ResultSpec::conv, extract_blind_sign_priv(), GNUNET_PQ_ResultSpec::fname, name, and res.

Here is the call graph for this function:

extract_blinded_sig()

static enum GNUNET_GenericReturnValue extract_blinded_sig ( 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 2157 of file pq_result_helper.c.

{
  struct GNUNET_CRYPTO_BlindedSignature **sig = dst;
  struct GNUNET_CRYPTO_BlindedSignature *bs;
  size_t len;
  const char *res;
  int fnum;
  uint32_t be[2];
 
  (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));
  if (0x01 != ntohl (be[1])) /* magic marker: blinded */
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  res += sizeof (be);
  len -= sizeof (be);
  bs = GNUNET_new (struct GNUNET_CRYPTO_BlindedSignature);
  bs->rc = 1;
  bs->cipher = ntohl (be[0]);
  switch (bs->cipher)
  {
  case GNUNET_CRYPTO_BSA_INVALID:
    break;
  case GNUNET_CRYPTO_BSA_RSA:
    bs->details.blinded_rsa_signature
      = GNUNET_CRYPTO_rsa_signature_decode (res,
                                            len);
    if (NULL == bs->details.blinded_rsa_signature)
    {
      GNUNET_break (0);
      GNUNET_free (bs);
      return GNUNET_SYSERR;
    }
    *sig = bs;
    return GNUNET_OK;
  case GNUNET_CRYPTO_BSA_CS:
    if (sizeof (bs->details.blinded_cs_answer) != len)
    {
      GNUNET_break (0);
      GNUNET_free (bs);
      return GNUNET_SYSERR;
    }
    GNUNET_memcpy (&bs->details.blinded_cs_answer,
                   res,
                   len);
    *sig = bs;
    return GNUNET_OK;
  }
  GNUNET_break (0);
  GNUNET_free (bs);
  return GNUNET_SYSERR;
}

References GNUNET_CRYPTO_BlindedSignature::blinded_cs_answer, GNUNET_CRYPTO_BlindedSignature::blinded_rsa_signature, GNUNET_CRYPTO_BlindedSignature::cipher, GNUNET_CRYPTO_BlindedSignature::details, GNUNET_break, GNUNET_CRYPTO_BSA_CS, GNUNET_CRYPTO_BSA_INVALID, GNUNET_CRYPTO_BSA_RSA, GNUNET_CRYPTO_rsa_signature_decode(), GNUNET_free, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_CRYPTO_BlindedSignature::rc, res, and result.

Referenced by GNUNET_PQ_result_spec_blinded_sig().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_blinded_sig()

static void clean_blinded_sig ( 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 2254 of file pq_result_helper.c.

{
  struct GNUNET_CRYPTO_BlindedSignature **b_sig = rd;
 
  (void) cls;
  GNUNET_CRYPTO_blinded_sig_decref (*b_sig);
}

References GNUNET_CRYPTO_blinded_sig_decref(), and rd.

Referenced by GNUNET_PQ_result_spec_blinded_sig().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_result_spec_blinded_sig()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_blinded_sig	(	const char *	name,
		struct GNUNET_CRYPTO_BlindedSignature **	b_sig
	)

Blinded signature expected.

Parameters

	name	name of the field in the table
[out]	b_sig	where to store the blinded signature

Returns

array entry for the result specification to use

Definition at line 2265 of file pq_result_helper.c.

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

References clean_blinded_sig(), GNUNET_PQ_ResultSpec::conv, extract_blinded_sig(), GNUNET_PQ_ResultSpec::fname, name, and res.

Here is the call graph for this function:

extract_unblinded_sig()

static enum GNUNET_GenericReturnValue extract_unblinded_sig ( 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 2294 of file pq_result_helper.c.

{
  struct GNUNET_CRYPTO_UnblindedSignature **sig = dst;
  struct GNUNET_CRYPTO_UnblindedSignature *ubs;
  size_t len;
  const char *res;
  int fnum;
  uint32_t be[2];
 
  (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));
  if (0x00 != ntohl (be[1])) /* magic marker: unblinded */
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  res += sizeof (be);
  len -= sizeof (be);
  ubs = GNUNET_new (struct GNUNET_CRYPTO_UnblindedSignature);
  ubs->rc = 1;
  ubs->cipher = ntohl (be[0]);
  switch (ubs->cipher)
  {
  case GNUNET_CRYPTO_BSA_INVALID:
    break;
  case GNUNET_CRYPTO_BSA_RSA:
    ubs->details.rsa_signature
      = GNUNET_CRYPTO_rsa_signature_decode (res,
                                            len);
    if (NULL == ubs->details.rsa_signature)
    {
      GNUNET_break (0);
      GNUNET_free (ubs);
      return GNUNET_SYSERR;
    }
    *sig = ubs;
    return GNUNET_OK;
  case GNUNET_CRYPTO_BSA_CS:
    if (sizeof (ubs->details.cs_signature) != len)
    {
      GNUNET_break (0);
      GNUNET_free (ubs);
      return GNUNET_SYSERR;
    }
    GNUNET_memcpy (&ubs->details.cs_signature,
                   res,
                   len);
    *sig = ubs;
    return GNUNET_OK;
  }
  GNUNET_break (0);
  GNUNET_free (ubs);
  return GNUNET_SYSERR;
}

References GNUNET_CRYPTO_UnblindedSignature::cipher, GNUNET_CRYPTO_UnblindedSignature::cs_signature, GNUNET_CRYPTO_UnblindedSignature::details, GNUNET_break, GNUNET_CRYPTO_BSA_CS, GNUNET_CRYPTO_BSA_INVALID, GNUNET_CRYPTO_BSA_RSA, GNUNET_CRYPTO_rsa_signature_decode(), GNUNET_free, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_CRYPTO_UnblindedSignature::rc, res, result, and GNUNET_CRYPTO_UnblindedSignature::rsa_signature.

Referenced by GNUNET_PQ_result_spec_unblinded_sig().

Here is the call graph for this function:

Here is the caller graph for this function:

clean_unblinded_sig()

static void clean_unblinded_sig ( 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 2391 of file pq_result_helper.c.

{
  struct GNUNET_CRYPTO_UnblindedSignature **ub_sig = rd;
 
  (void) cls;
  GNUNET_CRYPTO_unblinded_sig_decref (*ub_sig);
}

References GNUNET_CRYPTO_unblinded_sig_decref(), and rd.

Referenced by GNUNET_PQ_result_spec_unblinded_sig().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_result_spec_unblinded_sig()

struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_unblinded_sig	(	const char *	name,
		struct GNUNET_CRYPTO_UnblindedSignature **	ub_sig
	)

Unblinded signature expected.

Parameters

	name	name of the field in the table
[out]	ub_sig	where to store the unblinded signature

Returns

array entry for the result specification to use

Definition at line 2402 of file pq_result_helper.c.

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

References clean_unblinded_sig(), GNUNET_PQ_ResultSpec::conv, extract_unblinded_sig(), GNUNET_PQ_ResultSpec::fname, name, and res.

Here is the call graph for this function: