protocol v12 changes (/recoup split, signature changes) plus database sharding plus O(n^2)=>O(n) worst-case complexity reduction on coin balance checks

1 files changed, 373 insertions, 0 deletions

diff --git a/src/testing/testing_api_cmd_recoup_refresh.c b/src/testing/testing_api_cmd_recoup_refresh.c
new file mode 100644
index 000000000..bf265cbab
--- /dev/null
+++ b/src/testing/testing_api_cmd_recoup_refresh.c
@@ -0,0 +1,373 @@
+/*
+  This file is part of TALER
+  Copyright (C) 2014-2018 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 Foundation; either version 3, or
+  (at your option) any later version.
+
+  TALER is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public
+  License along with TALER; see the file COPYING.  If not, see
+  <http://www.gnu.org/licenses/>
+*/
+/**
+ * @file testing/testing_api_cmd_recoup_refresh.c
+ * @brief Implement the /recoup-refresh test command.
+ * @author Marcello Stanisci
+ */
+#include "platform.h"
+#include "taler_json_lib.h"
+#include <gnunet/gnunet_curl_lib.h>
+#include "taler_testing_lib.h"
+
+
+/**
+ * State for a "pay back" CMD.
+ */
+struct RecoupRefreshState
+{
+  /**
+   * Expected HTTP status code.
+   */
+  unsigned int expected_response_code;
+
+  /**
+   * Command that offers a reserve private key,
+   * plus a coin to be paid back.
+   */
+  const char *coin_reference;
+
+  /**
+   * Amount to be recouped.
+   */
+  struct TALER_Amount amount;
+
+  /**
+   * The interpreter state.
+   */
+  struct TALER_TESTING_Interpreter *is;
+
+  /**
+   * Handle to the ongoing operation.
+   */
+  struct TALER_EXCHANGE_RecoupRefreshHandle *ph;
+
+  /**
+   * NULL if coin was not refreshed, otherwise reference
+   * to the melt operation underlying @a coin_reference.
+   */
+  const char *melt_reference;
+
+};
+
+
+/**
+ * Parser reference to a coin.
+ *
+ * @param coin_reference of format $LABEL['#' $INDEX]?
+ * @param[out] cref where we return a copy of $LABEL
+ * @param[out] idx where we set $INDEX
+ * @return #GNUNET_SYSERR if $INDEX is present but not numeric
+ */
+static enum GNUNET_GenericReturnValue
+parse_coin_reference (const char *coin_reference,
+                      char **cref,
+                      unsigned int *idx)
+{
+  const char *index;
+
+  /* We allow command references of the form "$LABEL#$INDEX" or
+     just "$LABEL", which implies the index is 0. Figure out
+     which one it is. */
+  index = strchr (coin_reference, '#');
+  if (NULL == index)
+  {
+    *idx = 0;
+    *cref = GNUNET_strdup (coin_reference);
+    return GNUNET_OK;
+  }
+  *cref = GNUNET_strndup (coin_reference,
+                          index - coin_reference);
+  if (1 != sscanf (index + 1,
+                   "%u",
+                   idx))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Numeric index (not `%s') required after `#' in command reference of command in %s:%u\n",
+                index,
+                __FILE__,
+                __LINE__);
+    GNUNET_free (*cref);
+    *cref = NULL;
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Check the result of the recoup_refresh request: checks whether
+ * the HTTP response code is good, and that the coin that
+ * was paid back belonged to the right old coin.
+ *
+ * @param cls closure
+ * @param hr HTTP response details
+ * @param old_coin_pub public key of the dirty coin
+ */
+static void
+recoup_refresh_cb (void *cls,
+                   const struct TALER_EXCHANGE_HttpResponse *hr,
+                   const struct TALER_CoinSpendPublicKeyP *old_coin_pub)
+{
+  struct RecoupRefreshState *ps = cls;
+  struct TALER_TESTING_Interpreter *is = ps->is;
+  struct TALER_TESTING_Command *cmd = &is->commands[is->ip];
+  char *cref;
+  unsigned int idx;
+
+  ps->ph = NULL;
+  if (ps->expected_response_code != hr->http_status)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Unexpected response code %u/%d to command %s in %s:%u\n",
+                hr->http_status,
+                (int) hr->ec,
+                cmd->label,
+                __FILE__,
+                __LINE__);
+    json_dumpf (hr->reply,
+                stderr,
+                0);
+    fprintf (stderr, "\n");
+    TALER_TESTING_interpreter_fail (is);
+    return;
+  }
+
+  if (GNUNET_OK !=
+      parse_coin_reference (ps->coin_reference,
+                            &cref,
+                            &idx))
+  {
+    TALER_TESTING_interpreter_fail (is);
+    return;
+  }
+  (void) idx; /* do NOT use! We ignore 'idx', must be 0 for melt! */
+
+  GNUNET_free (cref);
+  switch (hr->http_status)
+  {
+  case MHD_HTTP_OK:
+    /* check old_coin_pub */
+    {
+      const struct TALER_TESTING_Command *melt_cmd;
+      const struct TALER_CoinSpendPrivateKeyP *dirty_priv;
+      struct TALER_CoinSpendPublicKeyP oc;
+
+      melt_cmd = TALER_TESTING_interpreter_lookup_command (is,
+                                                           ps->melt_reference);
+      if (NULL == melt_cmd)
+      {
+        GNUNET_break (0);
+        TALER_TESTING_interpreter_fail (is);
+        return;
+      }
+      if (GNUNET_OK !=
+          TALER_TESTING_get_trait_coin_priv (melt_cmd,
+                                             0,
+                                             &dirty_priv))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "Coin %u not found in command %s\n",
+                    0,
+                    ps->melt_reference);
+        GNUNET_break (0);
+        TALER_TESTING_interpreter_fail (is);
+        return;
+      }
+      GNUNET_CRYPTO_eddsa_key_get_public (&dirty_priv->eddsa_priv,
+                                          &oc.eddsa_pub);
+      if (0 != GNUNET_memcmp (&oc,
+                              old_coin_pub))
+      {
+        GNUNET_break (0);
+        TALER_TESTING_interpreter_fail (is);
+        return;
+      }
+    }
+    break;
+  case MHD_HTTP_NOT_FOUND:
+    break;
+  case MHD_HTTP_CONFLICT:
+    break;
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Unmanaged HTTP status code %u/%d.\n",
+                hr->http_status,
+                (int) hr->ec);
+    break;
+  }
+  TALER_TESTING_interpreter_next (is);
+}
+
+
+/**
+ * Run the command.
+ *
+ * @param cls closure.
+ * @param cmd the command to execute.
+ * @param is the interpreter state.
+ */
+static void
+recoup_refresh_run (void *cls,
+                    const struct TALER_TESTING_Command *cmd,
+                    struct TALER_TESTING_Interpreter *is)
+{
+  struct RecoupRefreshState *ps = cls;
+  const struct TALER_TESTING_Command *coin_cmd;
+  const struct TALER_CoinSpendPrivateKeyP *coin_priv;
+  const union TALER_DenominationBlindingKeyP *blinding_key;
+  const struct TALER_EXCHANGE_DenomPublicKey *denom_pub;
+  const struct TALER_DenominationSignature *coin_sig;
+  struct TALER_PlanchetSecretsP planchet;
+  char *cref;
+  unsigned int idx;
+
+  ps->is = is;
+  if (GNUNET_OK !=
+      parse_coin_reference (ps->coin_reference,
+                            &cref,
+                            &idx))
+  {
+    TALER_TESTING_interpreter_fail (is);
+    return;
+  }
+
+  coin_cmd = TALER_TESTING_interpreter_lookup_command (is,
+                                                       cref);
+  GNUNET_free (cref);
+
+  if (NULL == coin_cmd)
+  {
+    GNUNET_break (0);
+    TALER_TESTING_interpreter_fail (is);
+    return;
+  }
+
+  if (GNUNET_OK !=
+      TALER_TESTING_get_trait_coin_priv (coin_cmd,
+                                         idx,
+                                         &coin_priv))
+  {
+    GNUNET_break (0);
+    TALER_TESTING_interpreter_fail (is);
+    return;
+  }
+
+  if (GNUNET_OK !=
+      TALER_TESTING_get_trait_blinding_key (coin_cmd,
+                                            idx,
+                                            &blinding_key))
+  {
+    GNUNET_break (0);
+    TALER_TESTING_interpreter_fail (is);
+    return;
+  }
+  planchet.coin_priv = *coin_priv;
+  planchet.blinding_key = *blinding_key;
+
+  if (GNUNET_OK !=
+      TALER_TESTING_get_trait_denom_pub (coin_cmd,
+                                         idx,
+                                         &denom_pub))
+  {
+    GNUNET_break (0);
+    TALER_TESTING_interpreter_fail (is);
+    return;
+  }
+
+  if (GNUNET_OK !=
+      TALER_TESTING_get_trait_denom_sig (coin_cmd,
+                                         idx,
+                                         &coin_sig))
+  {
+    GNUNET_break (0);
+    TALER_TESTING_interpreter_fail (is);
+    return;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Trying to recoup_refresh denomination '%s'\n",
+              TALER_B2S (&denom_pub->h_key));
+
+  ps->ph = TALER_EXCHANGE_recoup_refresh (is->exchange,
+                                          denom_pub,
+                                          coin_sig,
+                                          &planchet,
+                                          &ps->amount,
+                                          recoup_refresh_cb,
+                                          ps);
+  GNUNET_assert (NULL != ps->ph);
+}
+
+
+/**
+ * Cleanup the "recoup_refresh" CMD state, and possibly cancel
+ * a pending operation thereof.
+ *
+ * @param cls closure.
+ * @param cmd the command which is being cleaned up.
+ */
+static void
+recoup_refresh_cleanup (void *cls,
+                        const struct TALER_TESTING_Command *cmd)
+{
+  struct RecoupRefreshState *ps = cls;
+  if (NULL != ps->ph)
+  {
+    TALER_EXCHANGE_recoup_refresh_cancel (ps->ph);
+    ps->ph = NULL;
+  }
+  GNUNET_free (ps);
+}
+
+
+struct TALER_TESTING_Command
+TALER_TESTING_cmd_recoup_refresh (const char *label,
+                                  unsigned int expected_response_code,
+                                  const char *coin_reference,
+                                  const char *melt_reference,
+                                  const char *amount)
+{
+  struct RecoupRefreshState *ps;
+
+  ps = GNUNET_new (struct RecoupRefreshState);
+  ps->expected_response_code = expected_response_code;
+  ps->coin_reference = coin_reference;
+  ps->melt_reference = melt_reference;
+  if (GNUNET_OK !=
+      TALER_string_to_amount (amount,
+                              &ps->amount))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to parse amount `%s' at %s\n",
+                amount,
+                label);
+    GNUNET_assert (0);
+  }
+  {
+    struct TALER_TESTING_Command cmd = {
+      .cls = ps,
+      .label = label,
+      .run = &recoup_refresh_run,
+      .cleanup = &recoup_refresh_cleanup
+    };
+
+    return cmd;
+  }
+}