path: root/src/backend/taler-merchant-httpd_exchanges.c

/*
  This file is part of TALER
  (C) 2014-2023 Taler Systems SA

  TALER is free software; you can redistribute it and/or modify it under the
  terms of the GNU Affero 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 taler-merchant-httpd_exchanges.c
 * @brief logic this HTTPD keeps for each exchange we interact with
 * @author Marcello Stanisci
 * @author Christian Grothoff
 */
#include "platform.h"
#include <taler/taler_json_lib.h>
#include "taler-merchant-httpd_exchanges.h"
#include "taler-merchant-httpd.h"
#include <regex.h>

/**
 * How often do we retry DB transactions with soft errors?
 */
#define MAX_RETRIES 3

/**
 * Minimum delay after which we'll re-fetch key information from the exchange.
 */
#define MIN_RELOAD_DELAY GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_MINUTES, 2)

/**
 * Delay after which we'll allow clients to force us to re-fetch key
 * information from the exchange if we don't know the denomination key.
 */
#define FORCED_RELOAD_DELAY GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_MINUTES, 15)

/**
 * Threshold after which exponential backoff should not increase.
 */
#define RETRY_BACKOFF_THRESHOLD GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_SECONDS, 60)


/**
 * Perform our exponential back-off calculation, starting at 1 ms
 * and then going by a factor of 2 up unto a maximum of RETRY_BACKOFF_THRESHOLD.
 *
 * @param r current backoff time, initially zero
 */
#define RETRY_BACKOFF(r) GNUNET_TIME_relative_min (RETRY_BACKOFF_THRESHOLD, \
                                                   GNUNET_TIME_relative_multiply ( \
                                                     GNUNET_TIME_relative_max ( \
                                                       GNUNET_TIME_UNIT_MILLISECONDS, \
                                                       (r)), 2));


/**
 * Information we keep for a pending #MMH_EXCHANGES_find_exchange() operation.
 */
struct TMH_EXCHANGES_FindOperation
{

  /**
   * Kept in a DLL.
   */
  struct TMH_EXCHANGES_FindOperation *next;

  /**
   * Kept in a DLL.
   */
  struct TMH_EXCHANGES_FindOperation *prev;

  /**
   * Function to call with the result.
   */
  TMH_EXCHANGES_FindContinuation fc;

  /**
   * Closure for @e fc.
   */
  void *fc_cls;

  /**
   * Exchange we wait for the /keys for.
   */
  struct TMH_Exchange *my_exchange;

  /**
   * Task scheduled to asynchronously return the result to
   * the find continuation.
   */
  struct GNUNET_SCHEDULER_Task *at;

};


/**
 * Information about wire transfer fees of an exchange, by wire method.
 */
struct FeesByWireMethod
{

  /**
   * Kept in a DLL.
   */
  struct FeesByWireMethod *next;

  /**
   * Kept in a DLL.
   */
  struct FeesByWireMethod *prev;

  /**
   * Wire method these fees are for.
   */
  char *wire_method;

  /**
   * Applicable fees, NULL if unknown/error.
   */
  struct TALER_EXCHANGE_WireAggregateFees *af;

};


/**
 * Restriction that applies to an exchange account.
 */
struct Restriction
{
  /**
   * Kept in a DLL.
   */
  struct Restriction *next;

  /**
   * Kept in a DLL.
   */
  struct Restriction *prev;

  /**
   * Type of restriction imposed on the account.
   */
  enum TALER_EXCHANGE_AccountRestrictionType type;

  /**
   * Details depending on @e type.
   */
  union
  {

    /**
     * Accounts must match the given regular expression.
     */
    struct
    {

      /**
       * Pre-compiled regex.
       */
      regex_t ex;

    } regex;

  } details;
};


/**
 * Information about a bank account of the exchange.
 */
struct ExchangeAccount
{
  /**
   * Kept in a DLL.
   */
  struct ExchangeAccount *next;

  /**
   * Kept in a DLL.
   */
  struct ExchangeAccount *prev;

  /**
   * Wire method of this exchange account.
   */
  char *wire_method;

  /**
   * Currency conversion that applies to this account,
   * NULL if none.
   */
  char *conversion_url;

  /**
   * Head of DLL of debit restrictions of this account.
   */
  struct Restriction *d_head;

  /**
   * Tail of DLL of debit restrictions of this account.
   */
  struct Restriction *d_tail;
};


/**
 * Exchange
 */
struct TMH_Exchange
{

  /**
   * Kept in a DLL.
   */
  struct TMH_Exchange *next;

  /**
   * Kept in a DLL.
   */
  struct TMH_Exchange *prev;

  /**
   * Head of FOs pending for this exchange.
   */
  struct TMH_EXCHANGES_FindOperation *fo_head;

  /**
   * Tail of FOs pending for this exchange.
   */
  struct TMH_EXCHANGES_FindOperation *fo_tail;

  /**
   * Head of accounts of this exchange.
   */
  struct ExchangeAccount *acc_head;

  /**
   * Tail of accounts of this exchange.
   */
  struct ExchangeAccount *acc_tail;

  /**
   * (base) URL of the exchange.
   */
  char *url;

  /**
   * A connection to this exchange
   */
  struct TALER_EXCHANGE_Handle *conn;

  /**
   * Active /wire request to the exchange, or NULL.
   */
  struct TALER_EXCHANGE_WireHandle *wire_request;

  /**
   * Task to re-run /wire after some delay.
   */
  struct GNUNET_SCHEDULER_Task *wire_task;

  /**
   * Head of wire fees from /wire request.
   */
  struct FeesByWireMethod *wire_fees_head;

  /**
   * Tail of wire fees from /wire request.
   */
  struct FeesByWireMethod *wire_fees_tail;

  /**
   * Master public key, guaranteed to be set ONLY for
   * trusted exchanges.
   */
  struct TALER_MasterPublicKeyP master_pub;

  /**
   * How soon can may we, at the earliest, re-download /keys?
   */
  struct GNUNET_TIME_Absolute first_retry;

  /**
   * How soon should we re-download /keys?
   */
  struct GNUNET_TIME_Timestamp keys_expiration;

  /**
   * How long should we wait between the next retry?
   */
  struct GNUNET_TIME_Relative retry_delay;

  /**
   * How long should we wait between the next retry for /wire?
   */
  struct GNUNET_TIME_Relative wire_retry_delay;

  /**
   * Task where we retry fetching /keys from the exchange.
   */
  struct GNUNET_SCHEDULER_Task *retry_task;

  /**
   * Falsoe to indicate that there is a /keys request
   * we are waiting for.
   * True to indicate that /keys data is up-to-date.
   */
  bool have_keys;

  /**
   * true if this exchange is from our configuration and
   * explicitly trusted, false if we need to check each
   * key to be sure it is trusted.
   */
  bool trusted;

  /**
   * true if this exchange did return to use the
   * response from /wire.
   */
  bool have_wire;

};


/**
 * Context for all exchange operations (useful to the event loop)
 */
static struct GNUNET_CURL_Context *merchant_curl_ctx;

/**
 * Context for integrating #merchant_curl_ctx with the
 * GNUnet event loop.
 */
static struct GNUNET_CURL_RescheduleContext *merchant_curl_rc;

/**
 * Head of exchanges we know about.
 */
static struct TMH_Exchange *exchange_head;

/**
 * Tail of exchanges we know about.
 */
static struct TMH_Exchange *exchange_tail;

/**
 * How many exchanges do we trust (for our configured
 * currency) as per our configuration? Used for a
 * sanity-check on startup.
 */
static int trusted_exchange_count;

/**
 * Function called with information about who is auditing
 * a particular exchange and what key the exchange is using.
 *
 * @param cls closure, will be `struct TMH_Exchange` so that
 *   when this function gets called, it will change the flag 'have_keys'
 *   to 'true'. Note: 'keys' is automatically saved inside the exchange's
 *   handle, which is contained inside 'struct TMH_Exchange', when
 *   this callback is called. Thus, once 'have_keys' turns 'true',
 *   it is safe to call 'TALER_EXCHANGE_get_keys()' on the exchange's handle,
 *   in order to get the "good" keys.
 * @param kr response details
 */
static void
keys_mgmt_cb (void *cls,
              const struct TALER_EXCHANGE_KeysResponse *kr);


/**
 * Free data structures within @a ea, but not @a ea
 * pointer itself.
 *
 * @param[in] ea data structure to free
 */
static void
free_exchange_account (struct ExchangeAccount *ea)
{
  struct Restriction *r;

  while (NULL != (r = ea->d_head))
  {
    GNUNET_CONTAINER_DLL_remove (ea->d_head,
                                 ea->d_tail,
                                 r);
    switch (r->type)
    {
    case TALER_EXCHANGE_AR_INVALID:
      GNUNET_assert (0);
      break;
    case TALER_EXCHANGE_AR_DENY:
      break;
    case TALER_EXCHANGE_AR_REGEX:
      regfree (&r->details.regex.ex);
      break;
    }
    GNUNET_free (r);
  }
  GNUNET_free (ea->wire_method);
  GNUNET_free (ea->conversion_url);
}


/**
 * Free list of all accounts in @a exchange.
 *
 * @param[in,out] exchange entry to free accounts for
 */
static void
purge_exchange_accounts (struct TMH_Exchange *exchange)
{
  struct ExchangeAccount *acc;

  while (NULL != (acc = exchange->acc_head))
  {
    GNUNET_CONTAINER_DLL_remove (exchange->acc_head,
                                 exchange->acc_tail,
                                 acc);
    free_exchange_account (acc);
    GNUNET_free (acc);
  }
}


/**
 * Set the list of accounts of @a exchange.
 *
 * @param[in,out] exchange exchange to initialize or update
 * @param accounts_len length of @a accounts array
 * @param accounts array of accounts to convert
 * @return #GNUNET_OK on success
 */
static enum GNUNET_GenericReturnValue
set_exchange_accounts (struct TMH_Exchange *exchange,
                       unsigned int accounts_len,
                       const struct TALER_EXCHANGE_WireAccount *accounts)
{
  purge_exchange_accounts (exchange);
  for (unsigned int i = 0; i<accounts_len; i++)
  {
    const struct TALER_EXCHANGE_WireAccount *account = &accounts[i];
    struct ExchangeAccount *acc;

    acc = GNUNET_new (struct ExchangeAccount);
    acc->wire_method = TALER_payto_get_method (account->payto_uri);
    if (NULL != account->conversion_url)
      acc->conversion_url = GNUNET_strdup (account->conversion_url);
    GNUNET_CONTAINER_DLL_insert (exchange->acc_head,
                                 exchange->acc_tail,
                                 acc);
    for (unsigned int j = 0; j<account->debit_restrictions_length; j++)
    {
      const struct TALER_EXCHANGE_AccountRestriction *ar =
        &account->debit_restrictions[j];
      struct Restriction *r;

      r = GNUNET_new (struct Restriction);
      r->type = ar->type;
      switch (ar->type)
      {
      case TALER_EXCHANGE_AR_INVALID:
        GNUNET_assert (0);
        break;
      case TALER_EXCHANGE_AR_DENY:
        break;
      case TALER_EXCHANGE_AR_REGEX:
        if (0 != regcomp (&r->details.regex.ex,
                          ar->details.regex.posix_egrep,
                          REG_NOSUB | REG_EXTENDED))
        {
          GNUNET_break_op (0);
          return GNUNET_SYSERR;
        }
        break;
      }
      GNUNET_CONTAINER_DLL_insert (acc->d_head,
                                   acc->d_tail,
                                   r);
    }
  }
  return GNUNET_OK;
}


/**
 * Retry getting information from the given exchange in
 * the closure.
 *
 * @param cls the exchange
 */
static void
retry_exchange (void *cls)
{
  struct TMH_Exchange *exchange = cls;

  /* might be a scheduled reload and not our first attempt */
  exchange->retry_task = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Connecting to exchange %s in retry_exchange()\n",
              exchange->url);
  if (NULL == exchange->conn)
  {
    exchange->conn = TALER_EXCHANGE_connect (merchant_curl_ctx,
                                             exchange->url,
                                             &keys_mgmt_cb,
                                             exchange,
                                             TALER_EXCHANGE_OPTION_END);
  }
  else
  {
    struct GNUNET_TIME_Timestamp next;

    next = TALER_EXCHANGE_check_keys_current (exchange->conn,
                                              TALER_EXCHANGE_CKF_NONE);
    if (! GNUNET_TIME_absolute_is_zero (next.abs_time))
    {
      exchange->retry_task = GNUNET_SCHEDULER_add_at (next.abs_time,
                                                      &retry_exchange,
                                                      exchange);
    }
  }
  /* Note: while the API spec says 'returns NULL on error', the implementation
     actually never returns NULL. */
  GNUNET_break (NULL != exchange->conn);
}


/**
 * Function called with information about the wire fees
 * for each wire method.  Stores the wire fees with the
 * exchange for later use.
 *
 * @param exchange connection to the exchange
 * @param master_pub public key of the exchange
 * @param num_methods number of wire methods supported
 * @param fbm wire fees by method
 * @return #TALER_EC_NONE on success
 */
static enum TALER_ErrorCode
process_wire_fees (struct TMH_Exchange *exchange,
                   const struct TALER_MasterPublicKeyP *master_pub,
                   unsigned int num_methods,
                   const struct TALER_EXCHANGE_WireFeesByMethod *fbm)
{
  for (unsigned int i = 0; i<num_methods; i++)
  {
    const char *wire_method = fbm[i].method;
    const struct TALER_EXCHANGE_WireAggregateFees *fees = fbm[i].fees_head;
    struct FeesByWireMethod *f;
    struct TALER_EXCHANGE_WireAggregateFees *endp;
    struct TALER_EXCHANGE_WireAggregateFees *af;

    for (f = exchange->wire_fees_head; NULL != f; f = f->next)
      if (0 == strcasecmp (wire_method,
                           f->wire_method))
        break;
    if (NULL == f)
    {
      f = GNUNET_new (struct FeesByWireMethod);
      f->wire_method = GNUNET_strdup (wire_method);
      GNUNET_CONTAINER_DLL_insert (exchange->wire_fees_head,
                                   exchange->wire_fees_tail,
                                   f);
    }
    endp = f->af;
    while ( (NULL != endp) &&
            (NULL != endp->next) )
      endp = endp->next;
    while ( (NULL != endp) &&
            (NULL != fees) &&
            (GNUNET_TIME_timestamp_cmp (fees->start_date,
                                        <,
                                        endp->end_date)) )
      fees = fees->next;
    if ( (NULL != endp) &&
         (NULL != fees) &&
         (GNUNET_TIME_timestamp_cmp (fees->start_date,
                                     !=,
                                     endp->end_date)) )
    {
      /* Hole in the fee structure, not allowed! */
      GNUNET_break_op (0);
      return TALER_EC_MERCHANT_GENERIC_HOLE_IN_WIRE_FEE_STRUCTURE;
    }
    while (NULL != fees)
    {
      struct GNUNET_HashCode h_wire_method;
      enum GNUNET_DB_QueryStatus qs;

      af = GNUNET_new (struct TALER_EXCHANGE_WireAggregateFees);
      *af = *fees;
      GNUNET_CRYPTO_hash (wire_method,
                          strlen (wire_method) + 1,
                          &h_wire_method);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Storing wire fee for `%s' and method `%s' at %s in DB; the fee is %s\n",
                  TALER_B2S (master_pub),
                  wire_method,
                  GNUNET_TIME_timestamp2s (af->start_date),
                  TALER_amount2s (&af->fees.wire));
      TMH_db->preflight (TMH_db->cls);
      if (GNUNET_OK !=
          TMH_db->start (TMH_db->cls,
                         "store wire fee"))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Failed to start database transaction to store exchange wire fees (will try to continue anyway)!\n");
        GNUNET_free (af);
        fees = fees->next;
        continue;
      }
      qs = TMH_db->store_wire_fee_by_exchange (TMH_db->cls,
                                               master_pub,
                                               &h_wire_method,
                                               &af->fees,
                                               af->start_date,
                                               af->end_date,
                                               &af->master_sig);
      if (0 > qs)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Failed to persist exchange wire fees in merchant DB (will try to continue anyway)!\n");
        GNUNET_free (af);
        fees = fees->next;
        TMH_db->rollback (TMH_db->cls);
        continue;
      }
      if (0 == qs)
      {
        /* Entry was already in DB, fine, continue as if we had succeeded */
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Fees already in DB, rolling back transaction attempt!\n");
        TMH_db->rollback (TMH_db->cls);
      }
      if (0 < qs)
      {
        /* Inserted into DB, make sure transaction completes */
        qs = TMH_db->commit (TMH_db->cls);
        if (0 > qs)
        {
          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                      "Failed to persist exchange wire fees in merchant DB (will try to continue anyway)!\n");
          GNUNET_free (af);
          fees = fees->next;
          continue;
        }
      }
      af->next = NULL;
      if (NULL == endp)
        f->af = af;
      else
        endp->next = af;
      endp = af;
      fees = fees->next;
    } /* all fees for this method */
  } /* for all methods (i) */
  return TALER_EC_NONE;
}


/**
 * Add account restriction @a a to array of @a restrictions.
 *
 * @param[in,out] restrictions JSON array to build
 * @param r restriction to add to @a restrictions
 * @return #GNUNET_SYSERR if @a r is malformed
 */
static enum GNUNET_GenericReturnValue
add_restriction (json_t *restrictions,
                 const struct TALER_EXCHANGE_AccountRestriction *r)
{
  json_t *jr;

  jr = NULL;
  switch (r->type)
  {
  case TALER_EXCHANGE_AR_INVALID:
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  case TALER_EXCHANGE_AR_DENY:
    jr = GNUNET_JSON_PACK (
      GNUNET_JSON_pack_string ("type",
                               "deny")
      );
    break;
  case TALER_EXCHANGE_AR_REGEX:
    jr = GNUNET_JSON_PACK (
      GNUNET_JSON_pack_string (
        "type",
        "regex"),
      GNUNET_JSON_pack_string (
        "regex",
        r->details.regex.posix_egrep),
      GNUNET_JSON_pack_string (
        "human_hint",
        r->details.regex.human_hint),
      GNUNET_JSON_pack_object_incref (
        "human_hint_i18n",
        (json_t *) r->details.regex.human_hint_i18n)
      );
    break;
  }
  if (NULL == jr)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  GNUNET_assert (0 ==
                 json_array_append_new (restrictions,
                                        jr));
  return GNUNET_OK;

}


/**
 * Function called with information about the wire accounts of the exchange.
 *
 * @param exchange the exchange
 * @param master_pub public key of the exchange
 * @param accounts_len length of the @a accounts array
 * @param accounts list of wire accounts of the exchange
 * @return #TALER_EC_NONE on success
 */
static enum TALER_ErrorCode
process_wire_accounts (struct TMH_Exchange *exchange,
                       const struct TALER_MasterPublicKeyP *master_pub,
                       unsigned int accounts_len,
                       const struct TALER_EXCHANGE_WireAccount *accounts)
{
  for (unsigned int r = 0; r<MAX_RETRIES; r++)
  {
    enum GNUNET_DB_QueryStatus qs;

    if (GNUNET_OK !=
        TMH_db->start (TMH_db->cls,
                       "update_exchange_accounts"))
    {
      TMH_db->rollback (TMH_db->cls);
      GNUNET_break (0);
      return TALER_EC_GENERIC_DB_START_FAILED;
    }
    qs = TMH_db->delete_exchange_accounts (TMH_db->cls,
                                           master_pub);
    if (qs < 0)
    {
      TMH_db->rollback (TMH_db->cls);
      if (GNUNET_DB_STATUS_SOFT_ERROR == qs)
        continue;
      GNUNET_break (0);
      return TALER_EC_GENERIC_DB_STORE_FAILED;
    }
    for (unsigned int i = 0; i<accounts_len; i++)
    {
      const struct TALER_EXCHANGE_WireAccount *account = &accounts[i];
      json_t *debit_restrictions;
      json_t *credit_restrictions;

      debit_restrictions = json_array ();
      GNUNET_assert (NULL != debit_restrictions);
      credit_restrictions = json_array ();
      GNUNET_assert (NULL != credit_restrictions);
      for (unsigned int j = 0; j<account->debit_restrictions_length; j++)
      {
        if (GNUNET_OK !=
            add_restriction (debit_restrictions,
                             &account->debit_restrictions[j]))
        {
          TMH_db->rollback (TMH_db->cls);
          GNUNET_break (0);
          json_decref (debit_restrictions);
          json_decref (credit_restrictions);
          return TALER_EC_MERCHANT_GENERIC_EXCHANGE_WIRE_REQUEST_FAILED;
        }
      }
      for (unsigned int j = 0; j<account->credit_restrictions_length; j++)
      {
        if (GNUNET_OK !=
            add_restriction (credit_restrictions,
                             &account->credit_restrictions[j]))
        {
          TMH_db->rollback (TMH_db->cls);
          GNUNET_break (0);
          json_decref (debit_restrictions);
          json_decref (credit_restrictions);
          return TALER_EC_MERCHANT_GENERIC_EXCHANGE_WIRE_REQUEST_FAILED;
        }
      }
      qs = TMH_db->insert_exchange_account (TMH_db->cls,
                                            master_pub,
                                            account->payto_uri,
                                            account->conversion_url,
                                            debit_restrictions,
                                            credit_restrictions,
                                            &account->master_sig);
      json_decref (debit_restrictions);
      json_decref (credit_restrictions);
      if (qs < 0)
      {
        TMH_db->rollback (TMH_db->cls);
        if (GNUNET_DB_STATUS_SOFT_ERROR == qs)
          goto outer;
        GNUNET_break (0);
        return TALER_EC_GENERIC_DB_STORE_FAILED;
      }
    }
    qs = TMH_db->commit (TMH_db->cls);
    if (qs < 0)
    {
      TMH_db->rollback (TMH_db->cls);
      if (GNUNET_DB_STATUS_SOFT_ERROR == qs)
        continue;
      GNUNET_break (0);
      return TALER_EC_GENERIC_DB_COMMIT_FAILED;
    }
    set_exchange_accounts (exchange,
                           accounts_len,
                           accounts);
    return TALER_EC_NONE;
outer:;
  }
  return TALER_EC_GENERIC_DB_SOFT_FAILURE;
}


/**
 * Obtain applicable fees for @a exchange and @a wire_method.
 *
 * @param exchange the exchange to query
 * @param now current time
 * @param wire_method the wire method we want the fees for
 * @return NULL if we do not have fees for this method yet
 */
static const struct FeesByWireMethod *
get_wire_fees (struct TMH_Exchange *exchange,
               struct GNUNET_TIME_Timestamp now,
               const char *wire_method)
{
  for (struct FeesByWireMethod *fbw = exchange->wire_fees_head;
       NULL != fbw;
       fbw = fbw->next)
  {
    if (0 == strcasecmp (fbw->wire_method,
                         wire_method) )
    {
      struct TALER_EXCHANGE_WireAggregateFees *af;

      /* Advance through list up to current time */
      while ( (NULL != (af = fbw->af)) &&
              (GNUNET_TIME_timestamp_cmp (now,
                                          >=,
                                          af->end_date)) )
      {
        fbw->af = af->next;
        GNUNET_free (af);
      }
      return fbw;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Exchange supports `%s' as a wire method (but we do not use that one)\n",
                fbw->wire_method);
  }
  return NULL;
}


/**
 * Check if we have any remaining pending requests for the
 * given @a exchange, and if we have the required data, call
 * the callback.
 *
 * @param exchange the exchange to check for pending find operations
 * @return true if we need /wire data from @a exchange
 */
static bool
process_find_operations (struct TMH_Exchange *exchange)
{
  struct TMH_EXCHANGES_FindOperation *fn;
  struct GNUNET_TIME_Timestamp now;

  if (! exchange->have_wire)
    return true;
  now = GNUNET_TIME_timestamp_get ();
  for (struct FeesByWireMethod *fbw = exchange->wire_fees_head;
       NULL != fbw;
       fbw = fbw->next)
  {
    bool removed = false;

    while ( (NULL != fbw->af) &&
            (GNUNET_TIME_timestamp_cmp (fbw->af->end_date,
                                        <,
                                        now)) )
    {
      struct TALER_EXCHANGE_WireAggregateFees *af = fbw->af;

      fbw->af = af->next;
      GNUNET_free (af);
      removed = true;
    }
    if (NULL == fbw->af)
    {
      /* Disagreement on the current time */
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Exchange has no wire fees configured for `%s' wire method\n",
                  fbw->wire_method);
      if (removed)
      {
        exchange->have_wire = false;
        return true; /* We just removed previous fees, try fetching update */
      }
    }
    if (GNUNET_TIME_timestamp_cmp (fbw->af->start_date,
                                   >,
                                   now))
    {
      /* Disagreement on the current time */
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Exchange's earliest fee is %s ahead of our time. Clock skew issue?\n",
                  GNUNET_TIME_relative2s (
                    GNUNET_TIME_absolute_get_remaining (
                      fbw->af->start_date.abs_time),
                    true));
    }
  }

  if (! exchange->have_wire)
    return true; /* need /wire response to continue */
  fn = NULL;
  for (struct TMH_EXCHANGES_FindOperation *fo = exchange->fo_head;
       NULL != fo;
       fo = fn)
  {
    struct TALER_EXCHANGE_HttpResponse hr = {
      .http_status = MHD_HTTP_OK,
    };

    fo->fc (fo->fc_cls,
            &hr,
            exchange->conn,
            exchange);
    fn = fo->next;
    TMH_EXCHANGES_find_exchange_cancel (fo);
  }
  return false;
}


static void
wire_task_cb (void *cls);


/**
 * Callbacks of this type are used to serve the result of submitting a
 * wire format inquiry request to a exchange.
 *
 * If the request fails to generate a valid response from the
 * exchange, @a http_status will also be zero.
 *
 * Must only be called if 'exchange->have_keys' is true.
 * that is #TALER_EXCHANGE_get_keys() will succeed.
 *
 * @param cls closure, a `struct TMH_Exchange`
 * @param wr response details
 */
static void
handle_wire_data (void *cls,
                  const struct TALER_EXCHANGE_WireResponse *wr)
{
  struct TMH_Exchange *exchange = cls;
  const struct TALER_EXCHANGE_Keys *keys;
  enum TALER_ErrorCode ecx;

  exchange->wire_request = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Received /wire response\n");
  if (MHD_HTTP_OK != wr->hr.http_status)
  {
    struct TMH_EXCHANGES_FindOperation *fo;

    exchange->have_wire = false;
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Failed to obtain /wire details from `%s': %u/%d\n",
                exchange->url,
                wr->hr.http_status,
                wr->hr.ec);
    while (NULL != (fo = exchange->fo_head))
    {
      fo->fc (fo->fc_cls,
              &wr->hr,
              exchange->conn,
              false);
      TMH_EXCHANGES_find_exchange_cancel (fo);
    }
    return;
  }
  keys = TALER_EXCHANGE_get_keys (exchange->conn);
  GNUNET_assert (NULL != keys);
  ecx = process_wire_accounts (exchange,
                               &keys->master_pub,
                               wr->details.ok.accounts_len,
                               wr->details.ok.accounts);
  if (TALER_EC_NONE == ecx)
    ecx = process_wire_fees (exchange,
                             &keys->master_pub,
                             wr->details.ok.fees_len,
                             wr->details.ok.fees);
  if (TALER_EC_NONE != ecx)
  {
    /* Report hard failure to all callbacks! */
    struct TMH_EXCHANGES_FindOperation *fo;
    struct TALER_EXCHANGE_HttpResponse hrx = {
      .ec = ecx,
      .http_status = 0,
      .reply = wr->hr.reply
    };

    GNUNET_break_op (0);
    exchange->have_wire = false;
    while (NULL != (fo = exchange->fo_head))
    {
      fo->fc (fo->fc_cls,
              &hrx,
              NULL,
              false);
      TMH_EXCHANGES_find_exchange_cancel (fo);
    }
    return;
  }
  exchange->have_wire = true;
  if ( (process_find_operations (exchange)) &&
       (NULL == exchange->wire_task) &&
       (NULL == exchange->wire_request) )
  {
    /* need to run /wire again. But as we DID get a successful reply,
       and as the exchange is unlikely to offer new wire methods very
       frequently, start with some significant delay */
    exchange->wire_retry_delay
      = GNUNET_TIME_relative_max (GNUNET_TIME_UNIT_MINUTES,
                                  exchange->wire_retry_delay);
    exchange->wire_retry_delay = RETRY_BACKOFF (exchange->wire_retry_delay);
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Need %s/wire, next download attempt in %s\n",
                exchange->url,
                GNUNET_STRINGS_relative_time_to_string (
                  exchange->wire_retry_delay,
                  true));
    exchange->wire_task
      = GNUNET_SCHEDULER_add_delayed (exchange->wire_retry_delay,
                                      &wire_task_cb,
                                      exchange);
  }
}


/**
 * Check if we have any remaining pending requests for the
 * given @a exchange, and if we have the required data, call
 * the callback.  If requests without /wire data remain,
 * retry the /wire request after some delay.
 *
 * Must only be called if 'exchange->have_keys' is true,
 * that is #TALER_EXCHANGE_get_keys() will succeed.
 *
 * @param cls a `struct TMH_Exchange` to check
 */
static void
wire_task_cb (void *cls)
{
  struct TMH_Exchange *exchange = cls;

  exchange->wire_task = NULL;
  GNUNET_assert (exchange->have_keys);
  if (! process_find_operations (exchange))
    return; /* no more need */
  GNUNET_assert (NULL == exchange->wire_request);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Initiating /wire download\n");
  exchange->wire_request = TALER_EXCHANGE_wire (exchange->conn,
                                                &handle_wire_data,
                                                exchange);
}


/**
 * Free @a exchange.
 *
 * @param[in] exchange entry to free
 */
static void
free_exchange_entry (struct TMH_Exchange *exchange)
{
  struct FeesByWireMethod *f;

  GNUNET_CONTAINER_DLL_remove (exchange_head,
                               exchange_tail,
                               exchange);
  purge_exchange_accounts (exchange);
  while (NULL != (f = exchange->wire_fees_head))
  {
    struct TALER_EXCHANGE_WireAggregateFees *af;

    GNUNET_CONTAINER_DLL_remove (exchange->wire_fees_head,
                                 exchange->wire_fees_tail,
                                 f);
    while (NULL != (af = f->af))
    {
      f->af = af->next;
      GNUNET_free (af);
    }
    GNUNET_free (f->wire_method);
    GNUNET_free (f);
  }
  if (NULL != exchange->wire_request)
  {
    TALER_EXCHANGE_wire_cancel (exchange->wire_request);
    exchange->wire_request = NULL;
  }
  if (NULL != exchange->wire_task)
  {
    GNUNET_SCHEDULER_cancel (exchange->wire_task);
    exchange->wire_task = NULL;
  }
  if (NULL != exchange->conn)
  {
    TALER_EXCHANGE_disconnect (exchange->conn);
    exchange->conn = NULL;
  }
  if (NULL != exchange->retry_task)
  {
    GNUNET_SCHEDULER_cancel (exchange->retry_task);
    exchange->retry_task = NULL;
  }
  GNUNET_assert (NULL == exchange->fo_head);
  GNUNET_assert (NULL == exchange->fo_tail);
  GNUNET_free (exchange->url);
  GNUNET_free (exchange);
}


/**
 * We failed downloading /keys from @a exchange. Tell clients
 * about our failure, abort pending operations and retry later.
 *
 * @param exchange exchange that failed
 * @param hr details about the HTTP reply
 */
static void
fail_and_retry (struct TMH_Exchange *exchange,
                const struct TALER_EXCHANGE_HttpResponse *hr)
{
  struct TMH_EXCHANGES_FindOperation *fo;

  exchange->have_keys = false;
  if (NULL != exchange->wire_request)
  {
    TALER_EXCHANGE_wire_cancel (exchange->wire_request);
    exchange->wire_request = NULL;
  }
  if (NULL != exchange->wire_task)
  {
    GNUNET_SCHEDULER_cancel (exchange->wire_task);
    exchange->wire_task = NULL;
  }
  while (NULL != (fo = exchange->fo_head))
  {
    fo->fc (fo->fc_cls,
            hr,
            NULL,
            false);
    TMH_EXCHANGES_find_exchange_cancel (fo);
  }
  if ( (NULL == exchange->fo_head) &&
       (TALER_EC_GENERIC_CONFIGURATION_INVALID == hr->ec) )
  {
    /* This can NEVER work, so don't retry */
    free_exchange_entry (exchange);
    return;
  }
  exchange->retry_delay = RETRY_BACKOFF (exchange->retry_delay);
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Failed to fetch /keys from `%s': %d/%u, retrying in %s\n",
              exchange->url,
              (int) hr->ec,
              hr->http_status,
              GNUNET_STRINGS_relative_time_to_string (exchange->retry_delay,
                                                      true));
  if (NULL != exchange->retry_task)
    GNUNET_SCHEDULER_cancel (exchange->retry_task);
  exchange->first_retry = GNUNET_TIME_relative_to_absolute (
    exchange->retry_delay);
  exchange->retry_task = GNUNET_SCHEDULER_add_delayed (exchange->retry_delay,
                                                       &retry_exchange,
                                                       exchange);
}


static void
keys_mgmt_cb (void *cls,
              const struct TALER_EXCHANGE_KeysResponse *kr)
{
  struct TMH_Exchange *exchange = cls;
  struct GNUNET_TIME_Relative delay;
  const struct TALER_EXCHANGE_Keys *keys;

  if (MHD_HTTP_OK != kr->hr.http_status)
  {
    fail_and_retry (exchange,
                    &kr->hr);
    return;
  }
  keys = kr->details.ok.keys;
  if ( (exchange->trusted) &&
       (0 != GNUNET_memcmp (&exchange->master_pub,
                            &keys->master_pub)) )
  {
    /* master pub differs => do not trust the exchange (without auditor) */
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Master public key of exchange `%s' differs from our configuration. Not trusting exchange.\n",
                exchange->url);
    exchange->trusted = false;
  }
  if (! exchange->trusted)
  {
    exchange->master_pub = keys->master_pub;
    for (struct TMH_Exchange *e = exchange_head;
         NULL != e;
         e = e->next)
    {
      if (e == exchange)
        continue;
      if (! e->trusted)
        continue;
      if (0 ==
          GNUNET_memcmp (&e->master_pub,
                         &exchange->master_pub))
        exchange->trusted = true; /* same exchange, different URL => trust applies */
    }
  }

  /* store exchange online signing keys in our DB */
  for (unsigned int i = 0; i<keys->num_sign_keys; i++)
  {
    struct TALER_EXCHANGE_SigningPublicKey *sign_key = &keys->sign_keys[i];
    enum GNUNET_DB_QueryStatus qs;

    TMH_db->preflight (TMH_db->cls);
    qs = TMH_db->insert_exchange_signkey (TMH_db->cls,
                                          &keys->master_pub,
                                          &sign_key->key,
                                          sign_key->valid_from,
                                          sign_key->valid_until,
                                          sign_key->valid_legal,
                                          &sign_key->master_sig);
    /* 0 is OK, we may already have the key in the DB! */
    if (0 > qs)
    {
      GNUNET_break (0);
      fail_and_retry (exchange,
                      &kr->hr);
      return;
    }
  }

  exchange->first_retry
    = GNUNET_TIME_relative_to_absolute (MIN_RELOAD_DELAY);
  exchange->keys_expiration
    = TALER_EXCHANGE_check_keys_current (exchange->conn,
                                         TALER_EXCHANGE_CKF_NONE);
  delay = GNUNET_TIME_absolute_get_remaining (
    exchange->keys_expiration.abs_time);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "/keys response from expires at %s! Retrying at that time!\n",
              GNUNET_TIME_absolute2s (
                exchange->keys_expiration.abs_time));
  delay = GNUNET_TIME_relative_max (delay,
                                    MIN_RELOAD_DELAY);
  exchange->retry_delay = GNUNET_TIME_UNIT_ZERO;
  if (NULL != exchange->retry_task)
    GNUNET_SCHEDULER_cancel (exchange->retry_task);
  exchange->retry_task
    = GNUNET_SCHEDULER_add_delayed (delay,
                                    &retry_exchange,
                                    exchange);
  exchange->have_keys = true;
  if ( (process_find_operations (exchange)) &&
       (NULL == exchange->wire_request) &&
       (NULL == exchange->wire_task) )
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Got key data, but also need wire data. Will request /wire now\n");
    exchange->wire_request
      = TALER_EXCHANGE_wire (exchange->conn,
                             &handle_wire_data,
                             exchange);
  }
}


/**
 * Task to return find operation result asynchronously to caller.
 *
 * @param cls a `struct TMH_EXCHANGES_FindOperation`
 */
static void
return_result (void *cls)
{
  struct TMH_EXCHANGES_FindOperation *fo = cls;
  struct TMH_Exchange *exchange = fo->my_exchange;

  fo->at = NULL;
  if ( (process_find_operations (exchange)) &&
       (NULL == exchange->wire_request) &&
       (exchange->have_keys) &&
       (NULL != exchange->wire_task) )
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Do not have current wire data. Will re-request /wire in %s\n",
                GNUNET_STRINGS_relative_time_to_string (
                  exchange->wire_retry_delay,
                  true));
    exchange->wire_task
      = GNUNET_SCHEDULER_add_delayed (exchange->wire_retry_delay,
                                      &wire_task_cb,
                                      exchange);
  }
}


/**
 * Lookup exchange by @a exchange_url.
 *
 * @param exchange_url base URL to match against
 * @return NULL if exchange is not yet known
 */
static struct TMH_Exchange *
lookup_exchange (const char *exchange_url)
{
  for (struct TMH_Exchange *exchange = exchange_head;
       NULL != exchange;
       exchange = exchange->next)
    if (0 == strcmp (exchange->url,
                     exchange_url))
      return exchange;
  return NULL;
}


struct TMH_EXCHANGES_FindOperation *
TMH_EXCHANGES_find_exchange (const char *chosen_exchange,
                             bool force_reload,
                             TMH_EXCHANGES_FindContinuation fc,
                             void *fc_cls)
{
  struct TMH_Exchange *exchange;
  struct TMH_EXCHANGES_FindOperation *fo;

  if (NULL == merchant_curl_ctx)
  {
    GNUNET_break (0);
    return NULL;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Trying to find chosen exchange `%s'\n",
              chosen_exchange);
  /* Check if the exchange is known */
  exchange = lookup_exchange (chosen_exchange);
  if (NULL == exchange)
  {
    /* This is a new exchange */
    exchange = GNUNET_new (struct TMH_Exchange);
    exchange->url = GNUNET_strdup (chosen_exchange);
    GNUNET_CONTAINER_DLL_insert (exchange_head,
                                 exchange_tail,
                                 exchange);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "The exchange `%s' is new\n",
                chosen_exchange);
  }

  fo = GNUNET_new (struct TMH_EXCHANGES_FindOperation);
  fo->fc = fc;
  fo->fc_cls = fc_cls;
  fo->my_exchange = exchange;
  GNUNET_CONTAINER_DLL_insert (exchange->fo_head,
                               exchange->fo_tail,
                               fo);

  if ( (GNUNET_TIME_absolute_is_past (exchange->first_retry)) &&
       (force_reload ||
        (GNUNET_TIME_absolute_is_past (
           exchange->keys_expiration.abs_time))) )
  {
    /* increment exponential-backoff */
    exchange->retry_delay = RETRY_BACKOFF (exchange->retry_delay);
    /* do not allow forced check until both backoff and #FORCED_RELOAD_DELAY
       are satisfied again */
    exchange->first_retry
      = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_max (
                                            exchange->retry_delay,
                                            FORCED_RELOAD_DELAY));
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "/keys retry forced, waiting until %s\n",
                GNUNET_TIME_absolute2s (exchange->first_retry));
    if (NULL == exchange->conn)
    {
      /* Not connected at all yet */
      exchange->retry_task
        = GNUNET_SCHEDULER_add_now (&retry_exchange,
                                    exchange);
    }
    else
    {
      /* Use existing connection, but update /keys */
      exchange->keys_expiration
        = TALER_EXCHANGE_check_keys_current (exchange->conn,
                                             TALER_EXCHANGE_CKF_FORCE_DOWNLOAD);
    }
    return fo;
  }

  if ( (exchange->have_keys) &&
       (exchange->have_wire) )
  {
    /* We are not currently waiting for a reply, immediately
       return result */
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "The exchange `%s' is ready\n",
                exchange->url);
    GNUNET_assert (NULL == fo->at);
    fo->at = GNUNET_SCHEDULER_add_now (&return_result,
                                       fo);
    return fo;
  }

  /* If new or resumed, (re)try fetching /keys */
  if ( (NULL == exchange->conn) &&
       (NULL == exchange->retry_task) &&
       (! exchange->have_keys) )
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Do not have current /keys data for `%s'. Will request /keys now\n",
                exchange->url);
    exchange->retry_task = GNUNET_SCHEDULER_add_now (&retry_exchange,
                                                     exchange);
    return fo;
  }
  if ( (exchange->have_keys) &&
       (! exchange->have_wire) &&
       (NULL == exchange->wire_task) &&
       (NULL == exchange->wire_request) )
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Do not have required /wire data. Will re-request %s/wire now\n",
                exchange->url);
    exchange->wire_task = GNUNET_SCHEDULER_add_now (&wire_task_cb,
                                                    exchange);
    return fo;
  }
  /* No activity to launch, we are already doing so */
  return fo;
}


void
TMH_EXCHANGES_find_exchange_cancel (struct TMH_EXCHANGES_FindOperation *fo)
{
  struct TMH_Exchange *exchange = fo->my_exchange;

  if (NULL != fo->at)
  {
    GNUNET_SCHEDULER_cancel (fo->at);
    fo->at = NULL;
  }
  GNUNET_CONTAINER_DLL_remove (exchange->fo_head,
                               exchange->fo_tail,
                               fo);
  GNUNET_free (fo);
}


/**
 * Function called on each configuration section. Finds sections
 * about exchanges, parses the entries and tries to connect to
 * it in order to fetch /keys.
 *
 * @param cls closure, with a `const struct GNUNET_CONFIGURATION_Handle *`
 * @param section name of the section
 */
static void
accept_exchanges (void *cls,
                  const char *section)
{
  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
  char *url;
  char *mks;
  struct TMH_Exchange *exchange;
  char *currency;

  if (0 != strncasecmp (section,
                        "merchant-exchange-",
                        strlen ("merchant-exchange-")))
    return;
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             section,
                                             "CURRENCY",
                                             &currency))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               section,
                               "CURRENCY");
    return;
  }
  if (0 != strcasecmp (currency,
                       TMH_currency))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Exchange given in section `%s' is for another currency. Skipping.\n",
                section);
    GNUNET_free (currency);
    return;
  }
  GNUNET_free (currency);
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             section,
                                             "EXCHANGE_BASE_URL",
                                             &url))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               section,
                               "EXCHANGE_BASE_URL");
    return;
  }
  exchange = GNUNET_new (struct TMH_Exchange);
  exchange->url = url;
  if (GNUNET_OK ==
      GNUNET_CONFIGURATION_get_value_string (cfg,
                                             section,
                                             "MASTER_KEY",
                                             &mks))
  {
    if (GNUNET_OK ==
        GNUNET_CRYPTO_eddsa_public_key_from_string (mks,
                                                    strlen (mks),
                                                    &exchange->master_pub.
                                                    eddsa_pub))
    {
      exchange->trusted = true;
      trusted_exchange_count++;
    }
    else
    {
      GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
                                 section,
                                 "MASTER_KEY",
                                 _ ("ill-formed EdDSA key"));
    }
    GNUNET_free (mks);
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "MASTER_KEY missing in section '%s', not trusting exchange\n",
                section);

  }
  GNUNET_CONTAINER_DLL_insert (exchange_head,
                               exchange_tail,
                               exchange);
  GNUNET_assert (NULL == exchange->retry_task);
  exchange->retry_task = GNUNET_SCHEDULER_add_now (&retry_exchange,
                                                   exchange);
}


enum GNUNET_GenericReturnValue
TMH_EXCHANGES_lookup_wire_fee (const char *exchange_url,
                               const char *wire_method,
                               struct TALER_Amount *wire_fee)
{
  struct TMH_Exchange *exchange;
  const struct FeesByWireMethod *fbm;
  const struct TALER_EXCHANGE_WireAggregateFees *af;

  exchange = lookup_exchange (exchange_url);
  if (NULL == exchange)
  {
    return GNUNET_SYSERR;
  }
  if (! exchange->have_wire)
  {
    return GNUNET_SYSERR;
  }
  fbm = get_wire_fees (exchange,
                       GNUNET_TIME_timestamp_get (),
                       wire_method);
  if (NULL == fbm)
    return GNUNET_NO;
  af = fbm->af;
  *wire_fee = af->fees.wire;
  return GNUNET_OK;
}


enum GNUNET_GenericReturnValue
TMH_EXCHANGES_init (const struct GNUNET_CONFIGURATION_Handle *cfg)
{
  merchant_curl_ctx
    = GNUNET_CURL_init (&GNUNET_CURL_gnunet_scheduler_reschedule,
                        &merchant_curl_rc);
  if (NULL == merchant_curl_ctx)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  merchant_curl_rc = GNUNET_CURL_gnunet_rc_create (merchant_curl_ctx);
  GNUNET_CURL_enable_async_scope_header (merchant_curl_ctx,
                                         "Taler-Correlation-Id");
  /* get exchanges from the merchant configuration and try to connect to them */
  GNUNET_CONFIGURATION_iterate_sections (cfg,
                                         &accept_exchanges,
                                         (void *) cfg);
  /* build JSON with list of trusted exchanges (will be included in contracts) */
  return trusted_exchange_count;
}


void
TMH_EXCHANGES_done ()
{
  while (NULL != exchange_head)
    free_exchange_entry (exchange_head);
  if (NULL != merchant_curl_ctx)
  {
    GNUNET_CURL_fini (merchant_curl_ctx);
    merchant_curl_ctx = NULL;
  }
  if (NULL != merchant_curl_rc)
  {
    GNUNET_CURL_gnunet_rc_destroy (merchant_curl_rc);
    merchant_curl_rc = NULL;
  }
}


enum GNUNET_GenericReturnValue
TMH_exchange_check_debit (struct TMH_Exchange *ex,
                          const struct TMH_WireMethod *wm)
{
  for (struct ExchangeAccount *acc = ex->acc_head;
       NULL != acc;
       acc = acc->next)
  {
    bool ok = true;

    if (0 != strcmp (acc->wire_method,
                     wm->wire_method))
      continue;
    if (NULL != acc->conversion_url)
      continue; /* never use accounts with conversion */
    for (struct Restriction *r = acc->d_head;
         NULL != r;
         r = r->next)
    {
      switch (r->type)
      {
      case TALER_EXCHANGE_AR_INVALID:
        GNUNET_break (0);
        ok = false;
        break;
      case TALER_EXCHANGE_AR_DENY:
        ok = false;
        break;
      case TALER_EXCHANGE_AR_REGEX:
        if (0 != regexec (&r->details.regex.ex,
                          wm->payto_uri,
                          0, NULL, 0))
          ok = false;
        break;
      }
      if (! ok)
        break;
    }

    if (ok)
      return GNUNET_OK;
  }
  return GNUNET_NO;
}


json_t *
TMH_exchange_get_acceptable (const struct TMH_WireMethod *wm)
{
  json_t *te = json_array ();

  GNUNET_assert (NULL != te);
  for (struct TMH_Exchange *exchange = exchange_head;
       NULL != exchange;
       exchange = exchange->next)
  {
    json_t *j_exchange;
    unsigned int priority;

    if (! exchange->trusted)
      continue;
    priority = 512; /* medium */
    if (exchange->have_wire)
    {
      if (GNUNET_OK ==
          TMH_exchange_check_debit (exchange,
                                    wm))
        priority = 1024; /* high */
      else
        priority = 0; /* negative response */
    }
    j_exchange = GNUNET_JSON_PACK (
      GNUNET_JSON_pack_string ("url",
                               exchange->url),
      GNUNET_JSON_pack_uint64 ("priority",
                               priority),
      GNUNET_JSON_pack_data_auto ("master_pub",
                                  &exchange->master_pub));
    GNUNET_assert (NULL != j_exchange);
    GNUNET_assert (0 ==
                   json_array_append_new (te,
                                          j_exchange));
  }
  return te;
}


/* end of taler-merchant-httpd_exchanges.c */