1 files changed, 636 insertions, 40 deletions

diff --git a/src/include/gnunet_pq_lib.h b/src/include/gnunet_pq_lib.h
index 2263704aa..7501bee12 100644
--- a/src/include/gnunet_pq_lib.h
+++ b/src/include/gnunet_pq_lib.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet
-   Copyright (C) 2016, 2017, 2020, 2021 GNUnet e.V.
+   Copyright (C) 2016, 2017, 2020-2022 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -25,9 +25,19 @@
 #ifndef GNUNET_PQ_LIB_H
 #define GNUNET_PQ_LIB_H
 
+
 #include <libpq-fe.h>
+#include <stdint.h>
+#include "gnunet_common.h"
+#include "gnunet_time_lib.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_db_lib.h"
+#include "postgres_ext.h"
+
+/**
+ * Postgres context.
+ */
+struct GNUNET_PQ_Context;
 
 /* ************************* pq_query_helper.c functions ************************ */
 
@@ -57,6 +67,14 @@ typedef int
                              void *scratch[],
                              unsigned int scratch_length);
 
+/**
+ * Function called to cleanup the closure of SQL parameters converter. Will be
+ * called with GNUNET_PQ_query_params_cleanup
+ *
+ * @param cls closure
+ */
+typedef void
+(*GNUNET_PQ_QueryConverter_Cleanup)(void *cls);
 
 /**
  * @brief Description of a DB query parameter.
@@ -70,10 +88,20 @@ struct GNUNET_PQ_QueryParam
 
   /**
    * Closure for @e conv.
+   * The function @conv_cls_cleanup can be set to cleanup the closure.
+   * The cleanup of the closure MUST be triggered manually by a call to
+   * GNUNET_PQ_query_params_cleanup.
    */
   void *conv_cls;
 
   /**
+   * Function to cleanup the closure @a conv_cls, may be NULL.
+   * The cleanup of the closure MUST be triggered manually by a call to
+   * GNUNET_PQ_query_params_cleanup.
+   */
+  GNUNET_PQ_QueryConverter_Cleanup conv_cls_cleanup;
+
+  /**
    * Data or NULL.
    */
   const void *data;
@@ -90,6 +118,15 @@ struct GNUNET_PQ_QueryParam
 
 };
 
+/**
+ * Must be called to cleanup memory from closures after the query parameters
+ * have been used as much as needed.
+ *
+ * @param params Array of GNUNET_PQ_QueryParam which must terminate with a GNUNET_PQ_query_param_end
+ */
+void
+GNUNET_PQ_cleanup_query_params_closures (
+  const struct GNUNET_PQ_QueryParam *params);
 
 /**
  * End of query parameter specification.
@@ -118,7 +155,7 @@ GNUNET_PQ_query_param_null (void);
  * @a ptr_size bytes.
  *
  * @param ptr pointer to the query parameter to pass
- * @oaran ptr_size number of bytes in @a ptr
+ * @param ptr_size number of bytes in @a ptr
  * @return query parameter to use
  */
 struct GNUNET_PQ_QueryParam
@@ -145,6 +182,210 @@ GNUNET_PQ_query_param_string (const char *ptr);
 struct GNUNET_PQ_QueryParam
 GNUNET_PQ_query_param_bool (bool b);
 
+/**
+ * Returns the oid for a given datatype by name.
+ *
+ * @param db The db-connection
+ * @param name The name of the datatype
+ * @param[out] oid The OID of the datatype.
+ * @return GNUNET_OK when the datatype was found, GNUNET_SYSERR otherwise
+ */
+enum GNUNET_GenericReturnValue
+GNUNET_PQ_get_oid_by_name (
+  struct GNUNET_PQ_Context *db,
+  const char *name,
+  Oid *oid);
+
+
+/**
+ * The header for a postgresql array in binary format. note that this a
+ * simplified special case of the general structure (which contains pointers),
+ * as we only support one-dimensional arrays.
+ *
+ * Note that all values must be in network-byte-order.
+ */
+struct GNUNET_PQ_ArrayHeader_P
+{
+  uint32_t ndim;     /* number of dimensions. we only support ndim = 1 */
+  uint32_t has_null;
+  uint32_t oid;      /* oid of the elements */
+  uint32_t dim;      /* size of the array */
+  uint32_t lbound;   /* index value of first element in the db (default: 1). */
+} __attribute__((packed));
+
+
+/**
+ * Generate query parameter for an array of bool in host byte order.
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Continuous array of @a num boolean elements
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+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 uint16_t in host byte order.
+ * Note that the (unsigend) elements are not checked to wrap over INT2_MAX
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Continuous array of @a num uint16 elements
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+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 uint32_t in host byte order.
+ * Note that the (unsigend) elements are not checked to wrap over INT4_MAX
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Continuous Array of @a num uint32_t elements
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+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 uint64 in host byte order.
+ * Note that the (unsigend) elements are not checked to wrap over INT8_MAX
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Continuous array of @a num uint64_t elements
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+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 buffers @a elements, each of
+ * corresponding size given in @a sizes.
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Continous array of @a num buffers, each of corresponding size given in @a sizes.
+ * @param sizes Pointer to sizes in bytes of each element in @a elements
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+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 @a elements,
+ * each of the same size @a size.
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Continous array of @a num buffers, each with the same size @a same_size
+ * @param same_size Size in bytes of each element in @a elements
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+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 array of equal-sized query parameter with size determined
+ * by variable type from a pointer to an continuous array.
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Continuous array of the query parameter to pass.
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+#define GNUNET_PQ_query_param_array_auto_from_type(num, elements, db) \
+  GNUNET_PQ_query_param_array_bytes_same_size ((num), \
+                                               (elements), \
+                                               sizeof(*(elements)), \
+                                               (db))
+
+/**
+ * Generate query parameter for an array of pointers to buffers @a elements,
+ * each of the same size @a size.
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num pointers to buffers, each with the same size @a same_size
+ * @param same_size Size in bytes of each element in @a elements
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+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 array of equal-sized query parameter with size determined by
+ * variable type from a pointer to an array of pointers to objects of the same
+ * type.
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Continuous array of the query parameter to pass.
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+#define GNUNET_PQ_query_param_array_ptrs_auto_from_type(num, elements, db) \
+  GNUNET_PQ_query_param_array_ptrs_bytes_same_size ((num), \
+                                                    (const void **) (elements), \
+                                                    sizeof(*(elements[0])), \
+                                                    (db))
+
+
+/**
+ * Generate query parameter for an array of strings (continuous)
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num continuous strings (zero-terminated each)
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+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 (pointers)
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num pointer to strings
+ * @param db Database context, needed for database-depending encoding of @a elements
+ * @return query parameter to use
+ */
+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 fixed-size query parameter with size determined
@@ -156,6 +397,83 @@ GNUNET_PQ_query_param_bool (bool b);
 #define GNUNET_PQ_query_param_auto_from_type(x) \
   GNUNET_PQ_query_param_fixed_size ((x), sizeof(*(x)))
 
+/**
+ * Generate query parameter for an array of absolute time stamps (continuous)
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num absolute timestamps
+ * @return query parameter to use
+ */
+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 (pointers)
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num pointers to absolute timestamps
+ * @return query parameter to use
+ */
+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 relative time stamps (continuous)
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num relative timestamps
+ * @return query parameter to use
+ */
+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 (pointers)
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num pointers to relative timestamps
+ * @return query parameter to use
+ */
+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 time stamps (continuous)
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num timestamps
+ * @return query parameter to use
+ */
+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 (pointers)
+ *
+ * @param num Number of elements in @a elements
+ * @param elements Array of @a num pointers to relative timestamps
+ * @return query parameter to use
+ */
+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 RSA public key.  The
@@ -235,7 +553,7 @@ GNUNET_PQ_query_param_absolute_time_nbo (
  */
 struct GNUNET_PQ_QueryParam
 GNUNET_PQ_query_param_timestamp_nbo (
-  const struct GNUNET_TIME_TimestampNBO *t);
+  const struct GNUNET_TIME_TimestampNBO *x);
 
 
 /**
@@ -259,7 +577,7 @@ GNUNET_PQ_query_param_uint32 (const uint32_t *x);
 
 
 /**
- * Generate query parameter for an uint16_t in host byte order.
+ * Generate query parameter for an uint64_t in host byte order.
  *
  * @param x pointer to the query parameter to pass
  * @return query parameter to use
@@ -268,6 +586,37 @@ struct GNUNET_PQ_QueryParam
 GNUNET_PQ_query_param_uint64 (const uint64_t *x);
 
 
+/**
+ * Generate query parameter for an int64_t in host byte order.
+ *
+ * @param x pointer to the query parameter to pass
+ * @return query parameter to use
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_int64 (const int64_t *x);
+
+/**
+ * Generate query parameter for a blind sign public key.
+ * Internally, the various attributes of the public key
+ * will be serialized into on variable-size BLOB.
+ *
+ * @param pub pointer to the query parameter to pass
+ *
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_blind_sign_pub (
+  const struct GNUNET_CRYPTO_BlindSignPublicKey *pub);
+
+/**
+ * Generate query parameter for a blind sign private key of variable size.
+ *
+ * @param priv pointer to the query parameter to pass
+ *
+ */
+struct GNUNET_PQ_QueryParam
+GNUNET_PQ_query_param_blind_sign_priv (
+  const struct GNUNET_CRYPTO_BlindSignPrivateKey *priv);
+
 /* ************************* pq_result_helper.c functions ************************ */
 
 
@@ -317,8 +666,7 @@ struct GNUNET_PQ_ResultSpec
   GNUNET_PQ_ResultConverter conv;
 
   /**
-   * Function to clean up result data, NULL if cleanup is
-   * not necessary.
+   * Function to clean up result data, NULL if cleanup is not necessary.
    */
   GNUNET_PQ_ResultCleanup cleaner;
 
@@ -333,9 +681,9 @@ struct GNUNET_PQ_ResultSpec
   void *dst;
 
   /**
-   * Allowed size for the data, 0 for variable-size
-   * (in this case, the type of @e dst is a `void **`
-   * and we need to allocate a buffer of the right size).
+   * Allowed size for the data, 0 for variable-size (in this case, the type of
+   * @e dst is a `void **` and we need to allocate a buffer of the right
+   * size).
    */
   size_t dst_size;
 
@@ -355,10 +703,8 @@ struct GNUNET_PQ_ResultSpec
   bool is_nullable;
 
   /**
-   * Points to a location where we should store
-   * "true" if the result found is NULL, and
-   * otherwise "false". Only used if @e is_nullable
-   * is true.
+   * Points to a location where we should store "true" if the result found is
+   * NULL, and otherwise "false". Only used if @e is_nullable is true.
    */
   bool *is_null;
 
@@ -385,8 +731,7 @@ struct GNUNET_PQ_ResultSpec
 
 
 /**
- * Allow NULL value to be found in the database
- * for the given value.
+ * Allow NULL value to be found in the database for the given value.
  *
  * @param rs result spec entry to modify
  * @param[out] is_null location set to 'true' if the
@@ -582,13 +927,231 @@ GNUNET_PQ_result_spec_uint64 (const char *name,
                               uint64_t *u64);
 
 
-/* ************************* pq.c functions ************************ */
+/**
+ * int64_t expected.
+ *
+ * @param name name of the field in the table
+ * @param[out] i64 where to store the result
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_int64 (const char *name,
+                             int64_t *i64);
+
 
 /**
- * Postgres context.
+ * array of bool expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements in the array @a bools.
+ * @param[out] bools pointer to where to store the result, an array of @a num bool's. Allocated by the function, MUST be freed with GNUNET_free.
+ * @return array entry for the result specification to use
  */
-struct GNUNET_PQ_Context;
+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 uint16_t expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements in the array @a u16s.
+ * @param[out] dst pointer to where to store the an array of @a num uint16_t's. Allocated by the function, MUST be freed with GNUNET_free.
+ * @return array entry for the result specification to use
+ */
+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 uint32_t expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements in the array @a u32s.
+ * @param[out] dst pointer to where to store the array of @a num uint32_t's. Allocated by the function, MUST be freed with GNUNET_free.
+ * @return array entry for the result specification to use
+ */
+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 uint64_t expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements in the array @a u64s.
+ * @param[out] dst pointer to where to store the array of @a num uint64_t's. Allocated by the function, MUST be freed with GNUNET_free.
+ * @return array entry for the result specification to use
+ */
+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 absolute time expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements in the array @a u64s.
+ * @param[out] dst pointer to where to store the array of @a num absolute time. Allocated by the function, MUST be freed with GNUNET_free.
+ * @return array entry for the result specification to use
+ */
+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 relative time expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements in the array @a u64s.
+ * @param[out] dst pointer to where to store the array of @a num relate time. Allocated by the function, MUST be freed with GNUNET_free.
+ * @return array entry for the result specification to use
+ */
+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.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements in the array @a u64s.
+ * @param[out] dst pointer to where to store the array of @a num timestamps. Allocated by the function, MUST be freed with GNUNET_free.
+ * @return array entry for the result specification to use
+ */
+
+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 variable-size result expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements
+ * @param[out] sizes where to store the @a num size's of byte-buffers in @a dst
+ * @param[out] dst where to store the continuous array of @a num byte-buffers , allocated
+ * @return array entry for the result specification to use
+ */
+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 fixed-size result expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param size number of bytes expected in each element of @a dst
+ * @param[out] num where to store the number of elements
+ * @param[out] dst where to store the results, an continuous array of fixed-size elements
+ * @return array entry for the result specification to use
+ */
+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);
+
+
+/**
+ * We expect a fixed-size result, with size determined by the type of `* dst`
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param num pointer to where to store the number of elements
+ * @param dst pointer to where to store the results, type fits expected result size
+ * @return array entry for the result specification to use
+ */
+#define GNUNET_PQ_result_spec_auto_array_from_type(db, name, num, dst) \
+  GNUNET_PQ_result_spec_array_fixed_size ( \
+    (db), \
+    (name), \
+    sizeof(*(dst)), \
+    (num), \
+    (void *) &(dst))
+
+
+/**
+ * Array of 0-terminated strings expected.
+ *
+ * @param db Database context, needed for OID lookup for the correct type
+ * @param name name of the field in the table
+ * @param[out] num where to store the number of elements
+ * @param[out] dst where to store the allocated continous array of @a num 0-terminated strings
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_array_string (
+  struct GNUNET_PQ_Context *db,
+  const char *name,
+  size_t *num,
+  char **dst);
+
+
+/**
+ * Blind sign public key expected.
+ *
+ * @param name name of the field in the table
+ * @param[out] public_key where to store the denomination signature
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_blind_sign_pub (
+  const char *name,
+  struct GNUNET_CRYPTO_BlindSignPublicKey **public_key);
+
+
+/**
+ * Blind sign private key expected.
+ *
+ * @param name name of the field in the table
+ * @param[out] private_key where to store the denomination signature
+ * @return array entry for the result specification to use
+ */
+struct GNUNET_PQ_ResultSpec
+GNUNET_PQ_result_spec_blind_sign_priv (
+  const char *name,
+  struct GNUNET_CRYPTO_BlindSignPrivateKey **private_key);
 
+/* ************************* pq.c functions ************************ */
 
 /**
  * Execute a prepared statement.
@@ -754,11 +1317,6 @@ struct GNUNET_PQ_PreparedStatement
    */
   const char *sql;
 
-  /**
-   * Number of arguments included in @e sql.
-   */
-  unsigned int num_arguments;
-
 };
 
 
@@ -767,7 +1325,7 @@ struct GNUNET_PQ_PreparedStatement
  */
 #define GNUNET_PQ_PREPARED_STATEMENT_END \
   {                                      \
-    NULL, NULL, 0                        \
+    NULL, NULL                           \
   }
 
 
@@ -776,13 +1334,11 @@ struct GNUNET_PQ_PreparedStatement
  *
  * @param name name of the statement
  * @param sql actual SQL statement
- * @param num_args number of arguments in the statement
  * @return initialized struct
  */
 struct GNUNET_PQ_PreparedStatement
 GNUNET_PQ_make_prepare (const char *name,
-                        const char *sql,
-                        unsigned int num_args);
+                        const char *sql);
 
 
 /**
@@ -799,6 +1355,22 @@ GNUNET_PQ_prepare_statements (struct GNUNET_PQ_Context *db,
                               const struct GNUNET_PQ_PreparedStatement *ps);
 
 
+/**
+ * Request creation of prepared statements @a ps from Postgres, but do not
+ * automatically re-prepare the statement if we are disconnected from the
+ * database.
+ *
+ * @param db database to prepare the statements for
+ * @param ps #GNUNET_PQ_PREPARED_STATEMENT_END-terminated array of prepared
+ *            statements.
+ * @return #GNUNET_OK on success,
+ *         #GNUNET_SYSERR on error
+ */
+enum GNUNET_GenericReturnValue
+GNUNET_PQ_prepare_once (struct GNUNET_PQ_Context *db,
+                        const struct GNUNET_PQ_PreparedStatement *ps);
+
+
 /* ******************** pq_exec.c functions ************** */
 
 
@@ -853,7 +1425,7 @@ GNUNET_PQ_make_try_execute (const char *sql);
 /**
  * Request execution of an array of statements @a es from Postgres.
  *
- * @param pq database to execute the statements in
+ * @param db database to execute the statements in
  * @param es #GNUNET_PQ_PREPARED_STATEMENT_END-terminated array of prepared
  *            statements.
  * @return #GNUNET_OK on success (modulo statements where errors can be ignored)
@@ -895,14 +1467,14 @@ enum GNUNET_PQ_Options
  * configuration.  Initialize logging via GNUnet's log routines and disable
  * Postgres's logger.  Also ensures that the statements in @a load_path and @a
  * es are executed whenever we (re)connect to the database, and that the
- * prepared statements in @a ps are "ready".  If statements in @es fail that
+ * prepared statements in @a ps are "ready".  If statements in @a es fail that
  * were created with #GNUNET_PQ_make_execute(), then the entire operation
  * fails.
  *
  * In @a load_path, a list of "$XXXX.sql" files is expected where $XXXX
  * must be a sequence of contiguous integer values starting at 0000.
  * These files are then loaded in sequence using "psql $config_str" before
- * running statements from @e es.  The directory is inspected again on
+ * running statements from @a es.  The directory is inspected again on
  * reconnect.
  *
  * @param config_str configuration to use
@@ -939,7 +1511,7 @@ GNUNET_PQ_exec_sql (struct GNUNET_PQ_Context *db,
  * configuration.  Initialize logging via GNUnet's log routines and disable
  * Postgres's logger.  Also ensures that the statements in @a load_path and @a
  * es are executed whenever we (re)connect to the database, and that the
- * prepared statements in @a ps are "ready".  If statements in @es fail that
+ * prepared statements in @a ps are "ready".  If statements in @a es fail that
  * were created with #GNUNET_PQ_make_execute(), then the entire operation
  * fails.
  *
@@ -968,10 +1540,10 @@ GNUNET_PQ_connect2 (const char *config_str,
 
 
 /**
- * Connect to a postgres database using the configuration
- * option "CONFIG" in @a section.  Also ensures that the
- * statements in @a es are executed whenever we (re)connect to the
- * database, and that the prepared statements in @a ps are "ready".
+ * Connect to a postgres database using the configuration option "CONFIG" in
+ * @a section.  Also ensures that the statements in @a es are executed
+ * whenever we (re)connect to the database, and that the prepared statements
+ * in @a ps are "ready".
  *
  * The caller does not have to ensure that @a es and @a ps remain allocated
  * and initialized in memory until #GNUNET_PQ_disconnect() is called, as a copy will be made.
@@ -999,7 +1571,8 @@ GNUNET_PQ_connect_with_cfg (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * database, and that the prepared statements in @a ps are "ready".
  *
  * The caller does not have to ensure that @a es and @a ps remain allocated
- * and initialized in memory until #GNUNET_PQ_disconnect() is called, as a copy will be made.
+ * and initialized in memory until #GNUNET_PQ_disconnect() is called, as a
+ * copy will be made.
  *
  * @param cfg configuration
  * @param section configuration section to use to get Postgres configuration options
@@ -1078,12 +1651,24 @@ GNUNET_PQ_event_listen_cancel (struct GNUNET_DB_EventHandler *eh);
 
 
 /**
+ * Poll for events right now. Useful if we may have
+ * triggered an event for ourselves.  Not needed when
+ * using GNUNET_PQ_event_notify(), but useful when
+ * stored procedures may have triggered events.
+ * Does nothing if there are no events.
+ *
+ * @param[in,out] db database to check for events
+ */
+void
+GNUNET_PQ_event_do_poll (struct GNUNET_PQ_Context *db);
+
+
+/**
  * Notify all that listen on @a es of an event.
  *
- * Unlike many other calls, this function is thread-safe
- * and may be called from threads that are different
- * from the one that setup @a db. However, the @a cb
- * will always be called from the thread that runs
+ * Unlike many other calls, this function is thread-safe and may be called
+ * from threads that are different from the one that setup @a db. However, the
+ * @a cb will always be called from the thread that runs
  * #GNUNET_PQ_event_do_poll() or the GNUnet scheduler.
  *
  * @param db database context to use
@@ -1099,6 +1684,17 @@ GNUNET_PQ_event_notify (struct GNUNET_PQ_Context *db,
 
 
 /**
+ * Compute the channel that one should notify upon for the given event
+ * specification.
+ *
+ * @param es event specification
+ * @return channel to notify upon
+ */
+char *
+GNUNET_PQ_get_event_notify_channel (const struct GNUNET_DB_EventHeaderP *es);
+
+
+/**
  * Within the @a db context, run all the SQL files
  * from the @a load_path from 0000-9999.sql (as long
  * as the files exist contiguously).