fix DB API for generic blinded planchet storage

2 files changed, 217 insertions, 1 deletions

diff --git a/src/pq/pq_query_helper.c b/src/pq/pq_query_helper.c
index ca1e94efb..8d6df60ce 100644
--- a/src/pq/pq_query_helper.c
+++ b/src/pq/pq_query_helper.c
@@ -1,6 +1,6 @@
 /*
   This file is part of TALER
-  Copyright (C) 2014, 2015, 2016, 2021 Taler Systems SA
+  Copyright (C) 2014, 2015, 2016, 2021, 2022 Taler Systems SA
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU General Public License as published by the Free Software
@@ -440,6 +440,97 @@ TALER_PQ_query_param_blinded_denom_sig (
  * Function called to convert input argument into SQL parameters.
  *
  * @param cls closure
+ * @param data pointer to input argument
+ * @param data_len number of bytes in @a data (if applicable)
+ * @param[out] param_values SQL data to set
+ * @param[out] param_lengths SQL length data to set
+ * @param[out] param_formats SQL format data to set
+ * @param param_length number of entries available in the @a param_values, @a param_lengths and @a param_formats arrays
+ * @param[out] scratch buffer for dynamic allocations (to be done via #GNUNET_malloc()
+ * @param scratch_length number of entries left in @a scratch
+ * @return -1 on error, number of offsets used in @a scratch otherwise
+ */
+static int
+qconv_blinded_planchet (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)
+{
+  const struct TALER_BlindedPlanchet *bp = data;
+  size_t tlen;
+  size_t len;
+  uint32_t be[2];
+  char *buf;
+
+  (void) cls;
+  (void) data_len;
+  GNUNET_assert (1 == param_length);
+  GNUNET_assert (scratch_length > 0);
+  GNUNET_break (NULL == cls);
+  be[0] = htonl ((uint32_t) bp->cipher);
+  be[1] = htonl (0x0100); /* magic marker: blinded */
+  switch (bp->cipher)
+  {
+  case TALER_DENOMINATION_RSA:
+    tlen = bp->details.rsa_blinded_planchet.blinded_msg_size;
+    break;
+  case TALER_DENOMINATION_CS:
+    tlen = sizeof (bp->details.cs_blinded_planchet);
+    break;
+  default:
+    GNUNET_assert (0);
+  }
+  len = tlen + sizeof (be);
+  buf = GNUNET_malloc (len);
+  memcpy (buf,
+          &be,
+          sizeof (be));
+  switch (bp->cipher)
+  {
+  case TALER_DENOMINATION_RSA:
+    memcpy (&buf[sizeof (be)],
+            bp->details.rsa_blinded_planchet.blinded_msg,
+            tlen);
+    break;
+  case TALER_DENOMINATION_CS:
+    memcpy (&buf[sizeof (be)],
+            &bp->details.cs_blinded_planchet,
+            tlen);
+    break;
+  default:
+    GNUNET_assert (0);
+  }
+  scratch[0] = buf;
+  param_values[0] = (void *) buf;
+  param_lengths[0] = len;
+  param_formats[0] = 1;
+  return 1;
+}
+
+
+struct GNUNET_PQ_QueryParam
+TALER_PQ_query_param_blinded_planchet (
+  const struct TALER_BlindedPlanchet *bp)
+{
+  struct GNUNET_PQ_QueryParam res = {
+    .conv = &qconv_blinded_planchet,
+    .data = bp,
+    .num_params = 1
+  };
+
+  return res;
+}
+
+
+/**
+ * Function called to convert input argument into SQL parameters.
+ *
+ * @param cls closure
  * @param data pointer to input argument, here a `json_t *`
  * @param data_len number of bytes in @a data (if applicable)
  * @param[out] param_values SQL data to set
diff --git a/src/pq/pq_result_helper.c b/src/pq/pq_result_helper.c
index 02733f298..6ee5da53e 100644
--- a/src/pq/pq_result_helper.c
+++ b/src/pq/pq_result_helper.c
@@ -730,4 +730,129 @@ TALER_PQ_result_spec_blinded_denom_sig (
 }
 
 
+/**
+ * Extract data from a Postgres database @a result at row @a row.
+ *
+ * @param cls closure
+ * @param result where to extract data from
+ * @param int row to extract data from
+ * @param fname name (or prefix) of the fields to extract from
+ * @param[in,out] dst_size where to store size of result, may be NULL
+ * @param[out] dst where to store the result
+ * @return
+ *   #GNUNET_YES if all results could be extracted
+ *   #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
+ */
+static enum GNUNET_GenericReturnValue
+extract_blinded_planchet (void *cls,
+                          PGresult *result,
+                          int row,
+                          const char *fname,
+                          size_t *dst_size,
+                          void *dst)
+{
+  struct TALER_BlindedPlanchet *bp = dst;
+  size_t len;
+  const char *res;
+  int fnum;
+  uint32_t be[2];
+
+  (void) cls;
+  (void) dst_size;
+  fnum = PQfnumber (result,
+                    fname);
+  if (fnum < 0)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  if (PQgetisnull (result,
+                   row,
+                   fnum))
+    return GNUNET_NO;
+
+  /* if a field is null, continue but
+   * remember that we now return a different result */
+  len = PQgetlength (result,
+                     row,
+                     fnum);
+  res = PQgetvalue (result,
+                    row,
+                    fnum);
+  if (len < sizeof (be))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  memcpy (&be,
+          res,
+          sizeof (be));
+  if (0x0100 != ntohl (be[1])) /* magic marker: blinded */
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  res += sizeof (be);
+  len -= sizeof (be);
+  bp->cipher = ntohl (be[0]);
+  switch (bp->cipher)
+  {
+  case TALER_DENOMINATION_RSA:
+    bp->details.rsa_blinded_planchet.blinded_msg_size
+      = len;
+    bp->details.rsa_blinded_planchet.blinded_msg
+      = GNUNET_memdup (res,
+                       len);
+    return GNUNET_OK;
+  case TALER_DENOMINATION_CS:
+    if (sizeof (bp->details.cs_blinded_planchet) != len)
+    {
+      GNUNET_break (0);
+      return GNUNET_SYSERR;
+    }
+    memcpy (&bp->details.cs_blinded_planchet,
+            res,
+            len);
+    return GNUNET_OK;
+  default:
+    GNUNET_break (0);
+  }
+  return GNUNET_SYSERR;
+}
+
+
+/**
+ * Function called to clean up memory allocated
+ * by a #GNUNET_PQ_ResultConverter.
+ *
+ * @param cls closure
+ * @param rd result data to clean up
+ */
+static void
+clean_blinded_planchet (void *cls,
+                        void *rd)
+{
+  struct TALER_BlindedPlanchet *bp = rd;
+
+  (void) cls;
+  TALER_blinded_planchet_free (bp);
+}
+
+
+struct GNUNET_PQ_ResultSpec
+TALER_PQ_result_spec_blinded_planchet (
+  const char *name,
+  struct TALER_BlindedPlanchet *bp)
+{
+  struct GNUNET_PQ_ResultSpec res = {
+    .conv = &extract_blinded_planchet,
+    .cleaner = &clean_blinded_planchet,
+    .dst = (void *) bp,
+    .fname = name
+  };
+
+  return res;
+}
+
+
 /* end of pq_result_helper.c */