pq_query_helper.c File Reference

functions to initialize parameter arrays More...

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

Include dependency graph for pq_query_helper.c:

Go to the source code of this file.

Data Structures
struct	qconv_array_cls
	Closure for the array type handlers. More...

Macros
#define	RETURN_UNLESS(cond)

Functions
static int	qconv_null (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
	Function called to convert input argument into SQL parameters.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_null (void)
	Generate query parameter to create a NULL value.
static int	qconv_fixed (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
	Function called to convert input argument into SQL parameters.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_fixed_size (const void *ptr, size_t ptr_size)
	Generate query parameter for a buffer ptr of ptr_size bytes.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_string (const char *ptr)
	Generate query parameter for a string.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_bool (bool b)
	Pass a boolean into a query.
static int	qconv_uint16 (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
	Function called to convert input argument into SQL parameters.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_uint16 (const uint16_t *x)
	Generate query parameter for an uint16_t in host byte order.
static int	qconv_uint32 (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
	Function called to convert input argument into SQL parameters.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_uint32 (const uint32_t *x)
	Generate query parameter for an uint32_t in host byte order.
static int	qconv_uint64 (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
	Function called to convert input argument into SQL parameters.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_uint64 (const uint64_t *x)
	Generate query parameter for an uint64_t in host byte order.
static int	qconv_int16 (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
	Function called to convert input argument into SQL parameters.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_int16 (const int16_t *x)
	Generate query parameter for an int16_t in host byte order.
static int	qconv_int64 (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
	Function called to convert input argument into SQL parameters.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_int64 (const int64_t *x)
	Generate query parameter for an int64_t in host byte order.
static int	qconv_rsa_public_key (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
	Function called to convert input argument into SQL parameters.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_rsa_public_key (const struct GNUNET_CRYPTO_RsaPublicKey *x)
	Generate query parameter for an RSA public key.
static int	qconv_rsa_signature (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
	Function called to convert input argument into SQL parameters.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_rsa_signature (const struct GNUNET_CRYPTO_RsaSignature *x)
	Generate query parameter for an RSA signature.
static int	qconv_rel_time (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
	Function called to convert input argument into SQL parameters.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_relative_time (const struct GNUNET_TIME_Relative *x)
	Generate query parameter for a relative time value.
static int	qconv_abs_time (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
	Function called to convert input argument into SQL parameters.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_absolute_time (const struct GNUNET_TIME_Absolute *x)
	Generate query parameter for an absolute time value.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_absolute_time_nbo (const struct GNUNET_TIME_AbsoluteNBO *x)
	Generate query parameter for an absolute time value.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_timestamp (const struct GNUNET_TIME_Timestamp *x)
	Generate query parameter for a timestamp.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_timestamp_nbo (const struct GNUNET_TIME_TimestampNBO *x)
	Generate query parameter for a timestamp in NBO.
static void	qconv_array_cls_cleanup (void *cls)
	Callback to cleanup a qconv_array_cls to be used during GNUNET_PQ_cleanup_query_params_closures.
static int	qconv_array (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
	Function called to convert input argument into SQL parameters for arrays.
static struct GNUNET_PQ_QueryParam	query_param_array_generic (unsigned int num, bool continuous, const void *elements, const size_t *sizes, size_t same_size, enum array_types typ, Oid oid)
	Function to generate a typ specific query parameter and corresponding closure.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_bool (unsigned int num, const bool *elements, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of bool in host byte order.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_uint16 (unsigned int num, const uint16_t *elements, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of uint16_t in host byte order.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_uint32 (unsigned int num, const uint32_t *elements, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of uint32_t in host byte order.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_uint64 (unsigned int num, const uint64_t *elements, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of uint64 in host byte order.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_bytes (unsigned int num, const void *elements, const size_t *sizes, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of buffers elements, each of corresponding size given in sizes.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_ptrs_bytes (unsigned int num, const void *elements[static num], const size_t *sizes, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of buffers elements, with sizes sizes.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_bytes_same_size (unsigned int num, const void *elements, size_t same_size, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of buffers elements, each of the same size size.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_ptrs_bytes_same_size (unsigned int num, const void *elements[static num], size_t same_size, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of pointers to buffers elements, each of the same size size.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_string (unsigned int num, const char *elements, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of strings (continuous)
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_ptrs_string (unsigned int num, const char *elements[static num], struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of strings (pointers)
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_abs_time (unsigned int num, const struct GNUNET_TIME_Absolute *elements, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of absolute time stamps (continuous)
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_ptrs_abs_time (unsigned int num, const struct GNUNET_TIME_Absolute *elements[], struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of absolute time stamps (pointers)
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_rel_time (unsigned int num, const struct GNUNET_TIME_Relative *elements, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of relative time stamps (continuous)
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_ptrs_rel_time (unsigned int num, const struct GNUNET_TIME_Relative *elements[], struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of relative time stamps (pointers)
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_timestamp (unsigned int num, const struct GNUNET_TIME_Timestamp *elements, struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of time stamps (continuous)
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_array_ptrs_timestamp (unsigned int num, const struct GNUNET_TIME_Timestamp *elements[], struct GNUNET_PQ_Context *db)
	Generate query parameter for an array of time stamps (pointers)
static int	qconv_blind_sign_pub (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
	Function called to convert input argument into SQL parameters.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_blind_sign_pub (const struct GNUNET_CRYPTO_BlindSignPublicKey *pub)
	Generate query parameter for a blind sign public key of variable size.
static int	qconv_blind_sign_priv (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
	Function called to convert input argument into SQL parameters.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_blind_sign_priv (const struct GNUNET_CRYPTO_BlindSignPrivateKey *priv)
	Generate query parameter for a blind sign private key of variable size.
static int	qconv_unblinded_sig (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
	Function called to convert input argument into SQL parameters.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_unblinded_sig (const struct GNUNET_CRYPTO_UnblindedSignature *sig)
	Generate query parameter for an unblinded signature of variable size.
static int	qconv_blinded_sig (void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
	Function called to convert input argument into SQL parameters.
struct GNUNET_PQ_QueryParam	GNUNET_PQ_query_param_blinded_sig (const struct GNUNET_CRYPTO_BlindedSignature *b_sig)
	Generate query parameter for a blinded signature of variable size.

Detailed Description

functions to initialize parameter arrays

Author

Christian Grothoff

Özgür Kesim

Definition in file pq_query_helper.c.

Macro Definition Documentation

RETURN_UNLESS

#define RETURN_UNLESS

(

cond

)

Value:

        do { \
          if (! (cond)) \
          { \
            GNUNET_break ((cond)); \
            noerror = false; \
            goto DONE; \
          } \
        } while (0)

Function Documentation

qconv_null()

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

static

Function called to convert input argument into SQL parameters.

Parameters

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

Returns

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

Definition at line 47 of file pq_query_helper.c.

{
  (void) scratch;
  (void) scratch_length;
  (void) data;
  (void) data_len;
  GNUNET_break (NULL == cls);
  if (1 != param_length)
    return -1;
  param_values[0] = NULL;
  param_lengths[0] = 0;
  param_formats[0] = 1;
  return 0;
}

References data, and GNUNET_break.

Referenced by GNUNET_PQ_query_param_null().

Here is the caller graph for this function:

GNUNET_PQ_query_param_null()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_null

(

void

)

Generate query parameter to create a NULL value.

Returns

query parameter to use to insert NULL into DB

Definition at line 72 of file pq_query_helper.c.

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

References GNUNET_PQ_QueryParam::conv, qconv_null(), and res.

Referenced by postgres_plugin_put().

Here is the call graph for this function:

Here is the caller graph for this function:

qconv_fixed()

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

static

Function called to convert input argument into SQL parameters.

Parameters

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

Returns

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

Definition at line 98 of file pq_query_helper.c.

{
  (void) scratch;
  (void) scratch_length;
  GNUNET_break (NULL == cls);
  if (1 != param_length)
    return -1;
  param_values[0] = (void *) data;
  param_lengths[0] = data_len;
  param_formats[0] = 1;
  return 0;
}

References data, and GNUNET_break.

Referenced by GNUNET_PQ_query_param_fixed_size().

Here is the caller graph for this function:

GNUNET_PQ_query_param_fixed_size()

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

Generate query parameter for a buffer ptr of ptr_size bytes.

Parameters

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

Returns

query parameter to use

Definition at line 121 of file pq_query_helper.c.

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

References GNUNET_PQ_QueryParam::conv, qconv_fixed(), res, and GNUNET_PQ_QueryParam::size.

Referenced by GNUNET_PQ_query_param_bool(), GNUNET_PQ_query_param_string(), namecache_postgres_cache_block(), namestore_postgres_store_records(), postgres_plugin_put(), postgres_plugin_put(), and postgres_plugin_remove_key().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_query_param_string()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_string

(

const char *

ptr

)

Generate query parameter for a string.

Parameters

ptr	pointer to the string query parameter to pass

Returns

query parameter to use

Definition at line 137 of file pq_query_helper.c.

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

References GNUNET_PQ_query_param_fixed_size().

Referenced by check_patch_applied(), GNUNET_PQ_get_oid_by_name(), namestore_postgres_clear_editor_hint(), namestore_postgres_edit_records(), namestore_postgres_lookup_records(), and namestore_postgres_store_records().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_query_param_bool()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_bool

(

bool

b

)

Pass a boolean into a query.

Parameters

b	boolean bit to pass

Returns

query parameter to use

Definition at line 145 of file pq_query_helper.c.

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

References GNUNET_PQ_query_param_fixed_size().

Here is the call graph for this function:

qconv_uint16()

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

static

Function called to convert input argument into SQL parameters.

Parameters

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

Returns

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

Definition at line 170 of file pq_query_helper.c.

{
  const uint16_t *u_hbo = data;
  uint16_t *u_nbo;
 
  (void) scratch;
  (void) scratch_length;
  GNUNET_break (NULL == cls);
  if (1 != param_length)
    return -1;
  u_nbo = GNUNET_new (uint16_t);
  scratch[0] = u_nbo;
  *u_nbo = htons (*u_hbo);
  param_values[0] = (void *) u_nbo;
  param_lengths[0] = sizeof(uint16_t);
  param_formats[0] = 1;
  return 1;
}

References data, GNUNET_break, and GNUNET_new.

Referenced by GNUNET_PQ_query_param_uint16().

Here is the caller graph for this function:

GNUNET_PQ_query_param_uint16()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_uint16

(

const uint16_t *

x

)

Generate query parameter for an uint16_t in host byte order.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 199 of file pq_query_helper.c.

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

References GNUNET_PQ_QueryParam::conv, qconv_uint16(), and res.

Referenced by postgres_plugin_get_key().

Here is the call graph for this function:

Here is the caller graph for this function:

qconv_uint32()

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

static

Function called to convert input argument into SQL parameters.

Parameters

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

Returns

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

Definition at line 227 of file pq_query_helper.c.

{
  const uint32_t *u_hbo = data;
  uint32_t *u_nbo;
 
  (void) scratch;
  (void) scratch_length;
  GNUNET_break (NULL == cls);
  if (1 != param_length)
    return -1;
  u_nbo = GNUNET_new (uint32_t);
  scratch[0] = u_nbo;
  *u_nbo = htonl (*u_hbo);
  param_values[0] = (void *) u_nbo;
  param_lengths[0] = sizeof(uint32_t);
  param_formats[0] = 1;
  return 1;
}

References data, GNUNET_break, and GNUNET_new.

Referenced by GNUNET_PQ_query_param_uint32().

Here is the caller graph for this function:

GNUNET_PQ_query_param_uint32()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_uint32

(

const uint32_t *

x

)

Generate query parameter for an uint32_t in host byte order.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 256 of file pq_query_helper.c.

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

References GNUNET_PQ_QueryParam::conv, qconv_uint32(), and res.

Referenced by namestore_postgres_store_records(), postgres_plugin_get(), postgres_plugin_get_closest(), postgres_plugin_get_key(), postgres_plugin_get_zero_anonymity(), postgres_plugin_put(), and postgres_plugin_put().

Here is the call graph for this function:

Here is the caller graph for this function:

qconv_uint64()

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

static

Function called to convert input argument into SQL parameters.

Parameters

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

Returns

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

Definition at line 284 of file pq_query_helper.c.

{
  const uint64_t *u_hbo = data;
  uint64_t *u_nbo;
 
  (void) scratch;
  (void) scratch_length;
  GNUNET_break (NULL == cls);
  if (1 != param_length)
    return -1;
  u_nbo = GNUNET_new (uint64_t);
  scratch[0] = u_nbo;
  *u_nbo = GNUNET_htonll (*u_hbo);
  param_values[0] = (void *) u_nbo;
  param_lengths[0] = sizeof(uint64_t);
  param_formats[0] = 1;
  return 1;
}

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

Referenced by GNUNET_PQ_query_param_uint64().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_query_param_uint64()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_uint64

(

const uint64_t *

x

)

Generate query parameter for an uint64_t in host byte order.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 313 of file pq_query_helper.c.

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

References GNUNET_PQ_QueryParam::conv, qconv_uint64(), and res.

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

Here is the call graph for this function:

Here is the caller graph for this function:

qconv_int16()

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

static

Function called to convert input argument into SQL parameters.

Parameters

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

Returns

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

Definition at line 341 of file pq_query_helper.c.

{
  const int16_t *u_hbo = data;
  int16_t *u_nbo;
 
  (void) scratch;
  (void) scratch_length;
  GNUNET_break (NULL == cls);
  if (1 != param_length)
    return -1;
  u_nbo = GNUNET_new (int16_t);
  scratch[0] = u_nbo;
  *u_nbo = GNUNET_htobe16 (*u_hbo);
  param_values[0] = (void *) u_nbo;
  param_lengths[0] = sizeof(int16_t);
  param_formats[0] = 1;
  return 1;
}

References data, GNUNET_break, GNUNET_htobe16, and GNUNET_new.

Referenced by GNUNET_PQ_query_param_int16().

Here is the caller graph for this function:

GNUNET_PQ_query_param_int16()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_int16

(

const int16_t *

x

)

Generate query parameter for an int16_t in host byte order.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 370 of file pq_query_helper.c.

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

References GNUNET_PQ_QueryParam::conv, qconv_int16(), and res.

Here is the call graph for this function:

qconv_int64()

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

static

Function called to convert input argument into SQL parameters.

Parameters

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

Returns

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

Definition at line 398 of file pq_query_helper.c.

{
  const int64_t *u_hbo = data;
  int64_t *u_nbo;
 
  (void) scratch;
  (void) scratch_length;
  GNUNET_break (NULL == cls);
  if (1 != param_length)
    return -1;
  u_nbo = GNUNET_new (int64_t);
  scratch[0] = u_nbo;
  *u_nbo = GNUNET_htonll (*u_hbo);
  param_values[0] = (void *) u_nbo;
  param_lengths[0] = sizeof(int64_t);
  param_formats[0] = 1;
  return 1;
}

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

Referenced by GNUNET_PQ_query_param_int64().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_query_param_int64()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_int64

(

const int64_t *

x

)

Generate query parameter for an int64_t in host byte order.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 427 of file pq_query_helper.c.

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

References GNUNET_PQ_QueryParam::conv, qconv_int64(), and res.

Here is the call graph for this function:

qconv_rsa_public_key()

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

static

Function called to convert input argument into SQL parameters.

Parameters

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

Returns

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

Definition at line 455 of file pq_query_helper.c.

{
  const struct GNUNET_CRYPTO_RsaPublicKey *rsa = data;
  void *buf;
  size_t buf_size;
 
  GNUNET_break (NULL == cls);
  if (1 != param_length)
    return -1;
  buf_size = GNUNET_CRYPTO_rsa_public_key_encode (rsa,
                                                  &buf);
  scratch[0] = buf;
  param_values[0] = (void *) buf;
  param_lengths[0] = buf_size;
  param_formats[0] = 1;
  return 1;
}

References data, GNUNET_break, and GNUNET_CRYPTO_rsa_public_key_encode().

Referenced by GNUNET_PQ_query_param_rsa_public_key().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_query_param_rsa_public_key()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_rsa_public_key

(

const struct GNUNET_CRYPTO_RsaPublicKey *

x

)

Generate query parameter for an RSA public key.

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

Parameters

x	the query parameter to pass.

Returns

query parameter to use

Definition at line 483 of file pq_query_helper.c.

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

References GNUNET_PQ_QueryParam::conv, qconv_rsa_public_key(), and res.

Here is the call graph for this function:

qconv_rsa_signature()

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

static

Function called to convert input argument into SQL parameters.

Parameters

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

Returns

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

Definition at line 511 of file pq_query_helper.c.

{
  const struct GNUNET_CRYPTO_RsaSignature *sig = data;
  void *buf;
  size_t buf_size;
 
  GNUNET_break (NULL == cls);
  if (1 != param_length)
    return -1;
  buf_size = GNUNET_CRYPTO_rsa_signature_encode (sig,
                                                 &buf);
  scratch[0] = buf;
  param_values[0] = (void *) buf;
  param_lengths[0] = buf_size;
  param_formats[0] = 1;
  return 1;
}

References data, GNUNET_break, and GNUNET_CRYPTO_rsa_signature_encode().

Referenced by GNUNET_PQ_query_param_rsa_signature().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_query_param_rsa_signature()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_rsa_signature

(

const struct GNUNET_CRYPTO_RsaSignature *

x

)

Generate query parameter for an RSA signature.

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

Parameters

x	the query parameter to pass

Returns

query parameter to use

Definition at line 539 of file pq_query_helper.c.

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

References GNUNET_PQ_QueryParam::conv, qconv_rsa_signature(), and res.

Here is the call graph for this function:

qconv_rel_time()

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

static

Function called to convert input argument into SQL parameters.

Parameters

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

Returns

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

Definition at line 566 of file pq_query_helper.c.

{
  const struct GNUNET_TIME_Relative *u = data;
  struct GNUNET_TIME_Relative rel;
  uint64_t *u_nbo;
 
  GNUNET_break (NULL == cls);
  if (1 != param_length)
    return -1;
  rel = *u;
  if (rel.rel_value_us > INT64_MAX)
    rel.rel_value_us = INT64_MAX;
  u_nbo = GNUNET_new (uint64_t);
  scratch[0] = u_nbo;
  *u_nbo = GNUNET_htonll (rel.rel_value_us);
  param_values[0] = (void *) u_nbo;
  param_lengths[0] = sizeof(uint64_t);
  param_formats[0] = 1;
  return 1;
}

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

Referenced by GNUNET_PQ_query_param_relative_time().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_query_param_relative_time()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_relative_time

(

const struct GNUNET_TIME_Relative *

x

)

Generate query parameter for a relative time value.

The database must store a 64-bit integer.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 597 of file pq_query_helper.c.

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

References GNUNET_PQ_QueryParam::conv, qconv_rel_time(), and res.

Here is the call graph for this function:

qconv_abs_time()

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

static

Function called to convert input argument into SQL parameters.

Parameters

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

Returns

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

Definition at line 625 of file pq_query_helper.c.

{
  const struct GNUNET_TIME_Absolute *u = data;
  struct GNUNET_TIME_Absolute abs;
  uint64_t *u_nbo;
 
  GNUNET_break (NULL == cls);
  if (1 != param_length)
    return -1;
  abs = *u;
  if (abs.abs_value_us > INT64_MAX)
    abs.abs_value_us = INT64_MAX;
  u_nbo = GNUNET_new (uint64_t);
  scratch[0] = u_nbo;
  *u_nbo = GNUNET_htonll (abs.abs_value_us);
  param_values[0] = (void *) u_nbo;
  param_lengths[0] = sizeof(uint64_t);
  param_formats[0] = 1;
  return 1;
}

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

Referenced by GNUNET_PQ_query_param_absolute_time().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_query_param_absolute_time()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_absolute_time

(

const struct GNUNET_TIME_Absolute *

x

)

Generate query parameter for an absolute time value.

The database must store a 64-bit integer.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 656 of file pq_query_helper.c.

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

References GNUNET_PQ_QueryParam::conv, qconv_abs_time(), and res.

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

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_query_param_absolute_time_nbo()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_absolute_time_nbo

(

const struct GNUNET_TIME_AbsoluteNBO *

x

)

Generate query parameter for an absolute time value.

The database must store a 64-bit integer.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 670 of file pq_query_helper.c.

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

References GNUNET_PQ_query_param_auto_from_type.

Referenced by GNUNET_PQ_query_param_timestamp_nbo().

Here is the caller graph for this function:

GNUNET_PQ_query_param_timestamp()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_timestamp

(

const struct GNUNET_TIME_Timestamp *

x

)

Generate query parameter for a timestamp.

The database must store a 64-bit integer.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 678 of file pq_query_helper.c.

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

References GNUNET_PQ_query_param_absolute_time().

Here is the call graph for this function:

GNUNET_PQ_query_param_timestamp_nbo()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_timestamp_nbo

(

const struct GNUNET_TIME_TimestampNBO *

x

)

Generate query parameter for a timestamp in NBO.

The database must store a 64-bit integer.

Parameters

x	pointer to the query parameter to pass

Returns

query parameter to use

Definition at line 685 of file pq_query_helper.c.

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

References GNUNET_PQ_query_param_absolute_time_nbo().

Here is the call graph for this function:

qconv_array_cls_cleanup()

static void qconv_array_cls_cleanup ( void *  cls )

static

Callback to cleanup a qconv_array_cls to be used during GNUNET_PQ_cleanup_query_params_closures.

Definition at line 737 of file pq_query_helper.c.

{
  GNUNET_free (cls);
}

References GNUNET_free.

Referenced by query_param_array_generic().

Here is the caller graph for this function:

qconv_array()

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

static

Function called to convert input argument into SQL parameters for arrays.

Note: the format for the encoding of arrays for libpq is not very well documented. We peeked into various sources (postgresql and libpqtypes) for guidance.

Parameters

	cls	Closure of type struct qconv_array_cls*
	data	Pointer to first element in the array
	data_len	Number of elements in array data (if applicable)
[out]	param_values	SQL data to set
[out]	param_lengths	SQL length data to set
[out]	param_formats	SQL format data to set
	param_length	number of entries available in the param_values, param_lengths and param_formats arrays
[out]	scratch	buffer for dynamic allocations (to be done via GNUNET_malloc()
	scratch_length	number of entries left in scratch

Returns

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

Definition at line 762 of file pq_query_helper.c.

{
  struct qconv_array_cls *meta = cls;
  size_t num = data_len;
  size_t total_size;
  const size_t *sizes;
  bool same_sized;
  size_t *string_lengths = NULL;
  void *elements = NULL;
  bool noerror = true;
  bool has_nulls = false;
  bool is_null[num];
 
  (void) (param_length);
  (void) (scratch_length);
 
  GNUNET_assert (NULL != meta);
  GNUNET_assert (num < INT_MAX);
 
  sizes = meta->sizes;
  same_sized = (0 != meta->same_size);
  memset (is_null, 0, num);
 
#define RETURN_UNLESS(cond) \
        do { \
          if (! (cond)) \
          { \
            GNUNET_break ((cond)); \
            noerror = false; \
            goto DONE; \
          } \
        } while (0)
 
  /* Calculate sizes and check bounds */
  {
    /* num * length-field */
    size_t x = sizeof(uint32_t);
    size_t y = x * num;
    RETURN_UNLESS ((0 == num) || (y / num == x));
 
    /* size of header */
    total_size  = x = sizeof(struct pq_array_header);
    total_size += y;
    RETURN_UNLESS (total_size >= x);
 
    /* sizes of elements */
    if (same_sized)
    {
      if (meta->continuous)
      {
        x = num * meta->same_size;
        RETURN_UNLESS ((0 == num) || (x / num == meta->same_size));
 
        y = total_size;
        total_size += x;
        RETURN_UNLESS (total_size >= y);
      }
      else
      {
        /* Not continuous, but same sized.
         * There might be NULL pointers in the array, though. */
        for (unsigned int i = 0; i < num; i++)
        {
          const void **ptr = (const void **) data;
 
          if (NULL != ptr[i])
          {
            total_size += meta->same_size;
            RETURN_UNLESS (total_size >= meta->same_size);
          }
          else
          {
            has_nulls = true;
            is_null[i] = true;
          }
        }
      }
    }
    else  /* sizes are different per element, provided in sizes[] */
    {
      /* For an array of strings we need to get their length's first */
      if (array_of_string == meta->typ)
      {
        string_lengths = GNUNET_new_array (num, size_t);
 
        if (meta->continuous)
        {
          const char *ptr = data;
 
          for (unsigned int i = 0; i < num; i++)
          {
            size_t len = strlen (ptr);
            RETURN_UNLESS (len < INT_MAX);
            string_lengths[i] = len;
            ptr += len + 1;
          }
        }
        else
        {
          const char **str = (const char **) data;
 
          for (unsigned int i = 0; i < num; i++)
          {
            if (NULL != str[i])
            {
              size_t len = strlen (str[i]);
              RETURN_UNLESS (len < INT_MAX);
              string_lengths[i] = len;
            }
            else
            {
              has_nulls = true;
              string_lengths[i] = 0;
              is_null[i] = true;
            }
          }
        }
        sizes = string_lengths;
      }
      else
      {
        /* Ensure consistency between NULL elements and sizes */
        for (unsigned int i = 0; i < num; i++)
        {
          const char **ptr = (const char **) data;
 
          if (NULL == ptr[i])
          {
            RETURN_UNLESS (sizes[i] == 0);
            has_nulls = true;
            is_null[i] = true;
          }
          else
            RETURN_UNLESS (sizes[i] < INT_MAX);
        }
      }
 
      for (unsigned int i = 0; i < num; i++)
      {
        x = total_size;
        total_size += sizes[i];
        RETURN_UNLESS (total_size >= x);
      }
    }
 
    RETURN_UNLESS (total_size < INT_MAX);
    elements = GNUNET_malloc (total_size);
  }
 
  /* Write data */
  {
    char *in = (char *) data;
    char *out = elements;
    struct pq_array_header h = {
      .ndim = htonl (1),        /* We only support one-dimensional arrays */
      .has_nulls = has_nulls ? htonl (1) : 0,
      .lbound = htonl (1),      /* Default start index value */
      .dim = htonl (num),
      .oid = htonl (meta->oid),
    };
 
    /* Write header */
    GNUNET_memcpy (out, &h, sizeof(h));
    out += sizeof(h);
 
 
    /* Write elements */
    for (unsigned int i = 0; i < num; i++)
    {
      size_t sz = same_sized ? meta->same_size : sizes[i];
      uint32_t hsz = is_null[i] ? htonl (-1) : htonl (sz);
 
      GNUNET_memcpy (out,
                     &hsz,
                     sizeof(hsz));
      out += sizeof(uint32_t);
 
      switch (meta->typ)
      {
      case array_of_bool:
        {
          GNUNET_assert (sizeof(bool) == sz);
          *(bool *) out = (*(bool *) in);
          in  += sz;
          break;
        }
      case array_of_uint16:
        {
          GNUNET_assert (sizeof(uint16_t) == sz);
          *(uint16_t *) out = htons (*(uint16_t *) in);
          in  += sz;
          break;
        }
      case array_of_uint32:
        {
          uint32_t v;
          GNUNET_assert (sizeof(uint32_t) == sz);
 
          v = htonl (*(uint32_t *) in);
          GNUNET_memcpy (out,
                         &v,
                         sizeof(v));
          in  += sz;
          break;
        }
      case array_of_uint64:
        {
          uint64_t tmp;
          GNUNET_assert (sizeof(uint64_t) == sz);
 
          tmp = GNUNET_htonll (*(uint64_t *) in);
          GNUNET_memcpy (out,
                         &tmp,
                         sizeof(tmp));
          in  += sz;
          break;
        }
      case array_of_byte:
      case array_of_string:
        if (! is_null[i])
        {
          const void *ptr;
 
          if (meta->continuous)
          {
            size_t nullbyte = (array_of_string == meta->typ) ? 1 : 0;
 
            ptr = in;
            in += sz + nullbyte;
          }
          else
            ptr = ((const char **) data)[i];
 
          RETURN_UNLESS (NULL != ptr);
          GNUNET_memcpy (out,
                         ptr,
                         sz);
        }
        break;
      case array_of_abs_time:
      case array_of_rel_time:
      case array_of_timestamp:
        if (! is_null [i])
        {
          uint64_t val;
 
          switch (meta->typ)
          {
          case array_of_abs_time:
            {
              const struct GNUNET_TIME_Absolute *abs =
                (const struct GNUNET_TIME_Absolute *) in;
 
              GNUNET_assert (sizeof(struct GNUNET_TIME_Absolute) == sz);
 
              if (! meta->continuous)
                abs = ((const struct GNUNET_TIME_Absolute **) data)[i];
 
              RETURN_UNLESS (NULL != abs);
              val = abs->abs_value_us;
              break;
            }
          case array_of_rel_time:
            {
              const struct GNUNET_TIME_Relative *rel =
                (const struct GNUNET_TIME_Relative *) in;
 
              GNUNET_assert (sizeof(struct GNUNET_TIME_Relative) == sz);
 
              if (! meta->continuous)
                rel = ((const struct GNUNET_TIME_Relative **) data)[i];
 
              RETURN_UNLESS (NULL != rel);
              val = rel->rel_value_us;
              break;
            }
          case array_of_timestamp:
            {
              const struct GNUNET_TIME_Timestamp *ts =
                (const struct GNUNET_TIME_Timestamp *) in;
 
              GNUNET_assert (sizeof(struct GNUNET_TIME_Timestamp) == sz);
 
              if (! meta->continuous)
                ts = ((const struct GNUNET_TIME_Timestamp **) data)[i];
 
              RETURN_UNLESS (NULL != ts);
              val = ts->abs_time.abs_value_us;
              break;
            }
          default:
            {
              GNUNET_assert (0);
            }
          }
 
          val = val > INT64_MAX ? INT64_MAX : val;
          val = GNUNET_htonll (val);
          GNUNET_memcpy (out,
                         &val,
                         sizeof(val));
 
          if (meta->continuous)
            in += sz;
        }
        break;
      default:
        GNUNET_assert (0);
        break;
      }
 
      if (! is_null[i])
        out += sz;
    }
  }
 
  param_values[0] = elements;
  param_lengths[0] = total_size;
  param_formats[0] = 1;
  scratch[0] = elements;
 
DONE:
  GNUNET_free (string_lengths);
 
  if (noerror)
    return 1;
 
  return -1;
}

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

Referenced by query_param_array_generic().

Here is the call graph for this function:

Here is the caller graph for this function:

query_param_array_generic()

static struct GNUNET_PQ_QueryParam query_param_array_generic ( unsigned int  num, bool  continuous, const void *  elements, const size_t *  sizes, size_t  same_size, enum array_types  typ, Oid  oid  )

static

Function to generate a typ specific query parameter and corresponding closure.

Parameters

num	Number of elements in elements
continuous	If true, elements is an continuous array of data
elements	Array of num elements, either continuous or pointers
sizes	Array of num sizes, one per element, may be NULL
same_size	If not 0, all elements in elements have this size
typ	Supported internal type of each element in elements
oid	Oid of the type to be used in Postgres

Returns

Query parameter

Definition at line 1115 of file pq_query_helper.c.

{
  struct qconv_array_cls *meta = GNUNET_new (struct qconv_array_cls);
 
  meta->typ = typ;
  meta->oid = oid;
  meta->sizes = sizes;
  meta->same_size = same_size;
  meta->continuous = continuous;
 
  {
    struct GNUNET_PQ_QueryParam res = {
      .conv = qconv_array,
      .conv_cls = meta,
      .conv_cls_cleanup = &qconv_array_cls_cleanup,
      .data = elements,
      .size = num,
      .num_params = 1,
    };
 
    return res;
  }
}

References qconv_array_cls::continuous, GNUNET_PQ_QueryParam::conv, GNUNET_new, meta, oid, qconv_array(), qconv_array_cls_cleanup(), res, qconv_array_cls::same_size, GNUNET_PQ_QueryParam::size, qconv_array_cls::sizes, and qconv_array_cls::typ.

Referenced by GNUNET_PQ_query_param_array_abs_time(), GNUNET_PQ_query_param_array_bool(), GNUNET_PQ_query_param_array_bytes(), GNUNET_PQ_query_param_array_bytes_same_size(), GNUNET_PQ_query_param_array_ptrs_abs_time(), GNUNET_PQ_query_param_array_ptrs_bytes(), GNUNET_PQ_query_param_array_ptrs_bytes_same_size(), GNUNET_PQ_query_param_array_ptrs_rel_time(), GNUNET_PQ_query_param_array_ptrs_string(), GNUNET_PQ_query_param_array_ptrs_timestamp(), GNUNET_PQ_query_param_array_rel_time(), GNUNET_PQ_query_param_array_string(), GNUNET_PQ_query_param_array_timestamp(), GNUNET_PQ_query_param_array_uint16(), GNUNET_PQ_query_param_array_uint32(), and GNUNET_PQ_query_param_array_uint64().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_query_param_array_bool()

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

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

Parameters

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

Returns

query parameter to use

Definition at line 1148 of file pq_query_helper.c.

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

References array_of_bool, db, GNUNET_assert, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_PQ_Context::num, oid, and query_param_array_generic().

Here is the call graph for this function:

GNUNET_PQ_query_param_array_uint16()

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

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

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

Parameters

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

Returns

query parameter to use

Definition at line 1170 of file pq_query_helper.c.

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

References array_of_uint16, db, GNUNET_assert, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_PQ_Context::num, oid, and query_param_array_generic().

Here is the call graph for this function:

GNUNET_PQ_query_param_array_uint32()

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

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

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

Parameters

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

Returns

query parameter to use

Definition at line 1192 of file pq_query_helper.c.

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

References array_of_uint32, db, GNUNET_assert, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_PQ_Context::num, oid, and query_param_array_generic().

Here is the call graph for this function:

GNUNET_PQ_query_param_array_uint64()

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

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

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

Parameters

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

Returns

query parameter to use

Definition at line 1214 of file pq_query_helper.c.

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

References array_of_uint64, db, GNUNET_assert, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_PQ_Context::num, oid, and query_param_array_generic().

Here is the call graph for this function:

GNUNET_PQ_query_param_array_bytes()

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

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

Parameters

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

Returns

query parameter to use

Definition at line 1236 of file pq_query_helper.c.

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

References array_of_byte, db, GNUNET_assert, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_PQ_Context::num, oid, and query_param_array_generic().

Here is the call graph for this function:

GNUNET_PQ_query_param_array_ptrs_bytes()

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

Generate query parameter for an array of buffers elements, with sizes sizes.

Parameters

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

Returns

query parameter to use

Definition at line 1259 of file pq_query_helper.c.

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

References array_of_byte, db, GNUNET_assert, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_PQ_Context::num, oid, and query_param_array_generic().

Here is the call graph for this function:

GNUNET_PQ_query_param_array_bytes_same_size()

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

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

Parameters

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

Returns

query parameter to use

Definition at line 1282 of file pq_query_helper.c.

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

References array_of_byte, db, GNUNET_assert, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_PQ_Context::num, oid, and query_param_array_generic().

Here is the call graph for this function:

GNUNET_PQ_query_param_array_ptrs_bytes_same_size()

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

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

Parameters

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

Returns

query parameter to use

Definition at line 1305 of file pq_query_helper.c.

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

References array_of_byte, db, GNUNET_assert, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_PQ_Context::num, oid, and query_param_array_generic().

Here is the call graph for this function:

GNUNET_PQ_query_param_array_string()

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

Generate query parameter for an array of strings (continuous)

Parameters

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

Returns

query parameter to use

Definition at line 1328 of file pq_query_helper.c.

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

References array_of_string, db, GNUNET_assert, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_PQ_Context::num, oid, and query_param_array_generic().

Here is the call graph for this function:

GNUNET_PQ_query_param_array_ptrs_string()

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

Generate query parameter for an array of strings (pointers)

Parameters

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

Returns

query parameter to use

Definition at line 1350 of file pq_query_helper.c.

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

References array_of_string, db, GNUNET_assert, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_PQ_Context::num, oid, and query_param_array_generic().

Here is the call graph for this function:

GNUNET_PQ_query_param_array_abs_time()

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

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

Parameters

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

Returns

query parameter to use

Definition at line 1372 of file pq_query_helper.c.

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

References array_of_abs_time, db, GNUNET_assert, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_PQ_Context::num, oid, and query_param_array_generic().

Here is the call graph for this function:

GNUNET_PQ_query_param_array_ptrs_abs_time()

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

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

Parameters

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

Returns

query parameter to use

Definition at line 1394 of file pq_query_helper.c.

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

References array_of_abs_time, db, GNUNET_assert, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_PQ_Context::num, oid, and query_param_array_generic().

Here is the call graph for this function:

GNUNET_PQ_query_param_array_rel_time()

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

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

Parameters

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

Returns

query parameter to use

Definition at line 1416 of file pq_query_helper.c.

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

References array_of_abs_time, db, GNUNET_assert, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_PQ_Context::num, oid, and query_param_array_generic().

Here is the call graph for this function:

GNUNET_PQ_query_param_array_ptrs_rel_time()

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

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

Parameters

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

Returns

query parameter to use

Definition at line 1438 of file pq_query_helper.c.

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

References array_of_abs_time, db, GNUNET_assert, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_PQ_Context::num, oid, and query_param_array_generic().

Here is the call graph for this function:

GNUNET_PQ_query_param_array_timestamp()

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

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

Parameters

num	Number of elements in elements
elements	Array of num timestamps

Returns

query parameter to use

Definition at line 1460 of file pq_query_helper.c.

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

References array_of_timestamp, db, GNUNET_assert, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_PQ_Context::num, oid, and query_param_array_generic().

Here is the call graph for this function:

GNUNET_PQ_query_param_array_ptrs_timestamp()

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

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

Parameters

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

Returns

query parameter to use

Definition at line 1482 of file pq_query_helper.c.

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

References array_of_timestamp, db, GNUNET_assert, GNUNET_OK, GNUNET_PQ_get_oid_by_name(), GNUNET_PQ_Context::num, oid, and query_param_array_generic().

Here is the call graph for this function:

qconv_blind_sign_pub()

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

static

Function called to convert input argument into SQL parameters.

Parameters

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

Returns

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

Definition at line 1518 of file pq_query_helper.c.

{
  const struct GNUNET_CRYPTO_BlindSignPublicKey *public_key = data;
  size_t tlen;
  size_t len;
  uint32_t be;
  char *buf;
  void *tbuf;
 
  (void) cls;
  (void) data_len;
  GNUNET_assert (1 == param_length);
  GNUNET_assert (scratch_length > 0);
  GNUNET_break (NULL == cls);
  be = htonl ((uint32_t) public_key->cipher);
  switch (public_key->cipher)
  {
  case GNUNET_CRYPTO_BSA_RSA:
    tlen = GNUNET_CRYPTO_rsa_public_key_encode (
      public_key->details.rsa_public_key,
      &tbuf);
    break;
  case GNUNET_CRYPTO_BSA_CS:
    tlen = sizeof (public_key->details.cs_public_key);
    break;
  default:
    GNUNET_assert (0);
  }
  len = tlen + sizeof (be);
  buf = GNUNET_malloc (len);
  GNUNET_memcpy (buf,
                 &be,
                 sizeof (be));
  switch (public_key->cipher)
  {
  case GNUNET_CRYPTO_BSA_RSA:
    GNUNET_memcpy (&buf[sizeof (be)],
                   tbuf,
                   tlen);
    GNUNET_free (tbuf);
    break;
  case GNUNET_CRYPTO_BSA_CS:
    GNUNET_memcpy (&buf[sizeof (be)],
                   &public_key->details.cs_public_key,
                   tlen);
    break;
  default:
    GNUNET_assert (0);
  }
 
  scratch[0] = buf;
  param_values[0] = (void *) buf;
  param_lengths[0] = len;
  param_formats[0] = 1;
  return 1;
}

References GNUNET_CRYPTO_BlindSignPublicKey::cipher, GNUNET_CRYPTO_BlindSignPublicKey::cs_public_key, data, GNUNET_CRYPTO_BlindSignPublicKey::details, GNUNET_assert, GNUNET_break, GNUNET_CRYPTO_BSA_CS, GNUNET_CRYPTO_BSA_RSA, GNUNET_CRYPTO_rsa_public_key_encode(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, and GNUNET_CRYPTO_BlindSignPublicKey::rsa_public_key.

Referenced by GNUNET_PQ_query_param_blind_sign_pub().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_query_param_blind_sign_pub()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_blind_sign_pub

(

const struct GNUNET_CRYPTO_BlindSignPublicKey *

pub

)

Generate query parameter for a blind sign public key of variable size.

Generate query parameter for a blind sign public key.

Parameters

pub	pointer to the query parameter to pass

Definition at line 1590 of file pq_query_helper.c.

{
  struct GNUNET_PQ_QueryParam res = {
    .conv = &qconv_blind_sign_pub,
    .data = pub,
    .num_params = 1
  };
 
  return res;
}

References GNUNET_PQ_QueryParam::conv, pub, qconv_blind_sign_pub(), and res.

Here is the call graph for this function:

qconv_blind_sign_priv()

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

static

Function called to convert input argument into SQL parameters.

Parameters

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

Returns

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

Definition at line 1618 of file pq_query_helper.c.

{
  const struct GNUNET_CRYPTO_BlindSignPrivateKey *private_key = data;
  size_t tlen;
  size_t len;
  uint32_t be;
  char *buf;
  void *tbuf;
 
  (void) cls;
  (void) data_len;
  GNUNET_assert (1 == param_length);
  GNUNET_assert (scratch_length > 0);
  GNUNET_break (NULL == cls);
  be = htonl ((uint32_t) private_key->cipher);
  switch (private_key->cipher)
  {
  case GNUNET_CRYPTO_BSA_RSA:
    tlen = GNUNET_CRYPTO_rsa_private_key_encode (
      private_key->details.rsa_private_key,
      &tbuf);
    break;
  case GNUNET_CRYPTO_BSA_CS:
    tlen = sizeof (private_key->details.cs_private_key);
    break;
  default:
    GNUNET_assert (0);
  }
  len = tlen + sizeof (be);
  buf = GNUNET_malloc (len);
  GNUNET_memcpy (buf,
                 &be,
                 sizeof (be));
  switch (private_key->cipher)
  {
  case GNUNET_CRYPTO_BSA_RSA:
    GNUNET_memcpy (&buf[sizeof (be)],
                   tbuf,
                   tlen);
    GNUNET_free (tbuf);
    break;
  case GNUNET_CRYPTO_BSA_CS:
    GNUNET_memcpy (&buf[sizeof (be)],
                   &private_key->details.cs_private_key,
                   tlen);
    break;
  default:
    GNUNET_assert (0);
  }
 
  scratch[0] = buf;
  param_values[0] = (void *) buf;
  param_lengths[0] = len;
  param_formats[0] = 1;
  return 1;
}

References GNUNET_CRYPTO_BlindSignPrivateKey::cipher, GNUNET_CRYPTO_BlindSignPrivateKey::cs_private_key, data, GNUNET_CRYPTO_BlindSignPrivateKey::details, GNUNET_assert, GNUNET_break, GNUNET_CRYPTO_BSA_CS, GNUNET_CRYPTO_BSA_RSA, GNUNET_CRYPTO_rsa_private_key_encode(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, and GNUNET_CRYPTO_BlindSignPrivateKey::rsa_private_key.

Referenced by GNUNET_PQ_query_param_blind_sign_priv().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_query_param_blind_sign_priv()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_blind_sign_priv

(

const struct GNUNET_CRYPTO_BlindSignPrivateKey *

priv

)

Generate query parameter for a blind sign private key of variable size.

Parameters

priv	pointer to the query parameter to pass

Definition at line 1690 of file pq_query_helper.c.

{
  struct GNUNET_PQ_QueryParam res = {
    .conv = &qconv_blind_sign_priv,
    .data = priv,
    .num_params = 1
  };
 
  return res;
}

References GNUNET_PQ_QueryParam::conv, qconv_blind_sign_priv(), and res.

Here is the call graph for this function:

qconv_unblinded_sig()

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

static

Function called to convert input argument into SQL parameters.

Parameters

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

Returns

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

Definition at line 1718 of file pq_query_helper.c.

{
  const struct GNUNET_CRYPTO_UnblindedSignature *ubs = data;
  size_t tlen;
  size_t len;
  uint32_t be[2];
  char *buf;
  void *tbuf;
 
  (void) cls;
  (void) data_len;
  GNUNET_assert (1 == param_length);
  GNUNET_assert (scratch_length > 0);
  GNUNET_break (NULL == cls);
  be[0] = htonl ((uint32_t) ubs->cipher);
  be[1] = htonl (0x00); /* magic marker: unblinded */
  switch (ubs->cipher)
  {
  case GNUNET_CRYPTO_BSA_RSA:
    tlen = GNUNET_CRYPTO_rsa_signature_encode (
      ubs->details.rsa_signature,
      &tbuf);
    break;
  case GNUNET_CRYPTO_BSA_CS:
    tlen = sizeof (ubs->details.cs_signature);
    break;
  default:
    GNUNET_assert (0);
  }
  len = tlen + sizeof (be);
  buf = GNUNET_malloc (len);
  GNUNET_memcpy (buf,
                 &be,
                 sizeof (be));
  switch (ubs->cipher)
  {
  case GNUNET_CRYPTO_BSA_RSA:
    GNUNET_memcpy (&buf[sizeof (be)],
                   tbuf,
                   tlen);
    GNUNET_free (tbuf);
    break;
  case GNUNET_CRYPTO_BSA_CS:
    GNUNET_memcpy (&buf[sizeof (be)],
                   &ubs->details.cs_signature,
                   tlen);
    break;
  default:
    GNUNET_assert (0);
  }
 
  scratch[0] = buf;
  param_values[0] = (void *) buf;
  param_lengths[0] = len;
  param_formats[0] = 1;
  return 1;
}

References GNUNET_CRYPTO_UnblindedSignature::cipher, GNUNET_CRYPTO_UnblindedSignature::cs_signature, data, GNUNET_CRYPTO_UnblindedSignature::details, GNUNET_assert, GNUNET_break, GNUNET_CRYPTO_BSA_CS, GNUNET_CRYPTO_BSA_RSA, GNUNET_CRYPTO_rsa_signature_encode(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, and GNUNET_CRYPTO_UnblindedSignature::rsa_signature.

Referenced by GNUNET_PQ_query_param_unblinded_sig().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_query_param_unblinded_sig()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_unblinded_sig

(

const struct GNUNET_CRYPTO_UnblindedSignature *

sig

)

Generate query parameter for an unblinded signature of variable size.

Parameters

sig	pointer to the query parameter to pass

Definition at line 1791 of file pq_query_helper.c.

{
  struct GNUNET_PQ_QueryParam res = {
    .conv = &qconv_unblinded_sig,
    .data = sig,
    .num_params = 1
  };
 
  return res;
}

References GNUNET_PQ_QueryParam::conv, qconv_unblinded_sig(), and res.

Here is the call graph for this function:

qconv_blinded_sig()

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

static

Function called to convert input argument into SQL parameters.

Parameters

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

Returns

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

Definition at line 1819 of file pq_query_helper.c.

{
  const struct GNUNET_CRYPTO_BlindedSignature *bs = data;
  size_t tlen;
  size_t len;
  uint32_t be[2];
  char *buf;
  void *tbuf;
 
  (void) cls;
  (void) data_len;
  GNUNET_assert (1 == param_length);
  GNUNET_assert (scratch_length > 0);
  GNUNET_break (NULL == cls);
  be[0] = htonl ((uint32_t) bs->cipher);
  be[1] = htonl (0x01); /* magic marker: blinded */
  switch (bs->cipher)
  {
  case GNUNET_CRYPTO_BSA_RSA:
    tlen = GNUNET_CRYPTO_rsa_signature_encode (
      bs->details.blinded_rsa_signature,
      &tbuf);
    break;
  case GNUNET_CRYPTO_BSA_CS:
    tlen = sizeof (bs->details.blinded_cs_answer);
    break;
  default:
    GNUNET_assert (0);
  }
  len = tlen + sizeof (be);
  buf = GNUNET_malloc (len);
  GNUNET_memcpy (buf,
                 &be,
                 sizeof (be));
  switch (bs->cipher)
  {
  case GNUNET_CRYPTO_BSA_RSA:
    GNUNET_memcpy (&buf[sizeof (be)],
                   tbuf,
                   tlen);
    GNUNET_free (tbuf);
    break;
  case GNUNET_CRYPTO_BSA_CS:
    GNUNET_memcpy (&buf[sizeof (be)],
                   &bs->details.blinded_cs_answer,
                   tlen);
    break;
  default:
    GNUNET_assert (0);
  }
 
  scratch[0] = buf;
  param_values[0] = (void *) buf;
  param_lengths[0] = len;
  param_formats[0] = 1;
  return 1;
}

References GNUNET_CRYPTO_BlindedSignature::blinded_cs_answer, GNUNET_CRYPTO_BlindedSignature::blinded_rsa_signature, GNUNET_CRYPTO_BlindedSignature::cipher, data, GNUNET_CRYPTO_BlindedSignature::details, GNUNET_assert, GNUNET_break, GNUNET_CRYPTO_BSA_CS, GNUNET_CRYPTO_BSA_RSA, GNUNET_CRYPTO_rsa_signature_encode(), GNUNET_free, GNUNET_malloc, and GNUNET_memcpy.

Referenced by GNUNET_PQ_query_param_blinded_sig().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_PQ_query_param_blinded_sig()

struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_blinded_sig

(

const struct GNUNET_CRYPTO_BlindedSignature *

b_sig

)

Generate query parameter for a blinded signature of variable size.

Parameters

b_sig

pointer to the query parameter to pass

Definition at line 1892 of file pq_query_helper.c.

{
  struct GNUNET_PQ_QueryParam res = {
    .conv = &qconv_blinded_sig,
    .data = b_sig,
    .num_params = 1
  };
 
  return res;
}

References GNUNET_PQ_QueryParam::conv, qconv_blinded_sig(), and res.

Here is the call graph for this function: