path: root/src/mint/test_mint_db.c

/*
  This file is part of TALER
  Copyright (C) 2014, 2015 Christian Grothoff (and other contributing authors)

  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, If not, see <http://www.gnu.org/licenses/>
*/

/**
 * @file mint/test_mint_db.c
 * @brief test cases for DB interaction functions
 * @author Sree Harsha Totakura <sreeharsha@totakura.in>
 */

#include "platform.h"
#include "mint_db.h"

static int result;

#define FAILIF(cond)                              \
  do {                                          \
    if (!(cond)){ break;}                      \
    GNUNET_break (0);                           \
    goto drop;                                  \
  } while (0)


#define RND_BLK(ptr)                                                    \
  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, ptr, sizeof (*ptr))

#define ZR_BLK(ptr) \
  memset (ptr, 0, sizeof (*ptr))


#define CURRENCY "EUR"

/**
 * Checks if the given reserve has the given amount of balance and expiry
 *
 * @param db the database connection
 * @param pub the public key of the reserve
 * @param value balance value
 * @param fraction balance fraction
 * @param currency currency of the reserve
 * @param expiry expiration of the reserve
 * @return #GNUNET_OK if the given reserve has the same balance and expiration
 *           as the given parameters; #GNUNET_SYSERR if not
 */
int
check_reserve (PGconn *db,
               struct GNUNET_CRYPTO_EddsaPublicKey *pub,
               uint32_t value, uint32_t fraction, const char *currency,
               uint64_t expiry)
{
  struct Reserve reserve;
  reserve.pub = pub;

  FAILIF (GNUNET_OK != TALER_MINT_DB_reserve_get (db, &reserve));
  FAILIF (value != reserve.balance.value);
  FAILIF (fraction != reserve.balance.fraction);
  FAILIF (0 != strcmp (currency, reserve.balance.currency));
  FAILIF (expiry != reserve.expiry.abs_value_us);

  return GNUNET_OK;
 drop:
  return GNUNET_SYSERR;
}


struct DenomKeyPair
{
  struct GNUNET_CRYPTO_rsa_PrivateKey *priv;
  struct GNUNET_CRYPTO_rsa_PublicKey *pub;
};

struct DenomKeyPair *
create_denom_key_pair (unsigned int size)
{
  struct DenomKeyPair *dkp;

  dkp = GNUNET_new (struct DenomKeyPair);
  dkp->priv = GNUNET_CRYPTO_rsa_private_key_create (size);
  GNUNET_assert (NULL != dkp->priv);
  dkp->pub = GNUNET_CRYPTO_rsa_private_key_get_public (dkp->priv);
  return dkp;
}

static void
destroy_denon_key_pair (struct DenomKeyPair *dkp)
{
  GNUNET_CRYPTO_rsa_public_key_free (dkp->pub);
  GNUNET_CRYPTO_rsa_private_key_free (dkp->priv);
  GNUNET_free (dkp);
}

/**
 * Main function that will be run by the scheduler.
 *
 * @param cls closure
 * @param args remaining command-line arguments
 * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 * @param config configuration
 */
static void
run (void *cls, char *const *args, const char *cfgfile,
     const struct GNUNET_CONFIGURATION_Handle *config)
{
  PGconn *db;
  struct GNUNET_CRYPTO_EddsaPublicKey reserve_pub;
  struct Reserve reserve;
  struct GNUNET_TIME_Absolute expiry;
  struct TALER_Amount amount;
  struct DenomKeyPair *dkp;
  struct GNUNET_HashCode h_blind;
  struct CollectableBlindcoin cbc;
  struct CollectableBlindcoin cbc2;
  struct ReserveHistory *rh;
  struct ReserveHistory *rh_head;
  struct BankTransfer *bt;
  struct CollectableBlindcoin *withdraw;
  struct Deposit deposit;
  struct Deposit deposit2;
  struct json_t *wire;
  const char * const json_wire_str =
      "{ \"type\":\"SEPA\", \
\"IBAN\":\"DE67830654080004822650\",                    \
\"name\":\"GNUnet e.V.\",                               \
\"bic\":\"GENODEF1SLR\",                                 \
\"edate\":\"1449930207000\",                                \
\"r\":123456789,                                     \
\"address\": \"foobar\"}";
  unsigned int cnt;

  db = NULL;
  dkp = NULL;
  rh = NULL;
  wire = NULL;
  ZR_BLK (&cbc);
  ZR_BLK (&cbc2);
  if (GNUNET_OK != TALER_MINT_DB_init ("postgres:///taler"))
  {
    result = 1;
    return;
  }
  if (GNUNET_OK != TALER_MINT_DB_create_tables (GNUNET_YES))
  {
    result = 2;
    goto drop;
  }
  if (NULL == (db = TALER_MINT_DB_get_connection(GNUNET_YES)))
  {
    result = 3;
    goto drop;
  }
  RND_BLK (&reserve_pub);
  reserve.pub = &reserve_pub;
  amount.value = 1;
  amount.fraction = 1;
  strcpy (amount.currency, CURRENCY);
  expiry = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
                                     GNUNET_TIME_UNIT_HOURS);
  result = 4;
  FAILIF (GNUNET_OK != TALER_MINT_DB_reserves_in_insert (db,
                                                         &reserve,
                                                         amount,
                                                         expiry));
  FAILIF (GNUNET_OK != check_reserve (db,
                                      &reserve_pub,
                                      amount.value,
                                      amount.fraction,
                                      amount.currency,
                                      expiry.abs_value_us));
  FAILIF (GNUNET_OK != TALER_MINT_DB_reserves_in_insert (db,
                                                         &reserve,
                                                         amount,
                                                         expiry));
  FAILIF (GNUNET_OK != check_reserve (db,
                                      &reserve_pub,
                                      ++amount.value,
                                      ++amount.fraction,
                                      amount.currency,
                                      expiry.abs_value_us));
  dkp = create_denom_key_pair (1024);
  RND_BLK(&h_blind);
  RND_BLK(&cbc.reserve_sig);
  cbc.denom_pub = dkp->pub;
  cbc.sig = GNUNET_CRYPTO_rsa_sign (dkp->priv, &h_blind, sizeof (h_blind));
  (void) memcpy (&cbc.reserve_pub, &reserve_pub, sizeof (reserve_pub));
  amount.value--;
  amount.fraction--;
  FAILIF (GNUNET_OK != TALER_MINT_DB_insert_collectable_blindcoin (db,
                                                                   &h_blind,
                                                                   amount,
                                                                   &cbc));
  FAILIF (GNUNET_OK != check_reserve (db,
                                      &reserve_pub,
                                      amount.value,
                                      amount.fraction,
                                      amount.currency,
                                      expiry.abs_value_us));
  FAILIF (GNUNET_YES != TALER_MINT_DB_get_collectable_blindcoin (db,
                                                                 &h_blind,
                                                                 &cbc2));
  FAILIF (NULL == cbc2.denom_pub);
  FAILIF (0 != memcmp (&cbc2.reserve_sig, &cbc.reserve_sig, sizeof (cbc2.reserve_sig)));
  FAILIF (0 != memcmp (&cbc2.reserve_pub, &cbc.reserve_pub, sizeof (cbc2.reserve_pub)));
  FAILIF (GNUNET_OK != GNUNET_CRYPTO_rsa_verify (&h_blind, cbc2.sig, dkp->pub));
  rh_head = rh = TALER_MINT_DB_get_reserve_history (db, &reserve_pub);
  FAILIF (NULL == rh);
  for (cnt=0; NULL != rh_head; rh_head=rh_head->next, cnt++)
  {
    switch (rh_head->type)
    {
    case TALER_MINT_DB_RO_BANK_TO_MINT:
      bt = rh_head->details.bank;
      FAILIF (0 != memcmp (&bt->reserve_pub, &reserve_pub, sizeof (reserve_pub)));
      FAILIF (1 != bt->amount.value);
      FAILIF (1 != bt->amount.fraction);
      FAILIF (0 != strcmp (CURRENCY, bt->amount.currency));
      FAILIF (NULL != bt->wire); /* FIXME: write wire details to db */
      break;
    case TALER_MINT_DB_RO_WITHDRAW_COIN:
      withdraw = rh_head->details.withdraw;
      FAILIF (0 != memcmp (&withdraw->reserve_pub,
                           &reserve_pub,
                           sizeof (reserve_pub)));
      FAILIF (0 != memcmp (&withdraw->h_coin_envelope,
                           &h_blind, sizeof (h_blind)));
      break;
    }
  }
  FAILIF (3 != cnt);
  /* Tests for deposits */
  RND_BLK (&deposit.coin.coin_pub);
  deposit.coin.denom_pub = dkp->pub;
  deposit.coin.denom_sig = cbc.sig;
  RND_BLK (&deposit.csig);
  RND_BLK (&deposit.merchant_pub);
  RND_BLK (&deposit.h_contract);
  RND_BLK (&deposit.h_wire);
  wire = json_loads (json_wire_str, 0, NULL);
  deposit.wire = wire;
  deposit.transaction_id =
      GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
  deposit.amount = amount;
  FAILIF (GNUNET_OK != TALER_MINT_DB_insert_deposit (db, &deposit));
  FAILIF (GNUNET_YES != TALER_MINT_DB_have_deposit (db, &deposit));
  (void) memcpy (&deposit2, &deposit, sizeof (deposit));
  deposit2.transaction_id++;     /* should fail if transaction id is different */
  FAILIF (GNUNET_NO != TALER_MINT_DB_have_deposit (db, &deposit2));
  deposit2.transaction_id = deposit.transaction_id;
  RND_BLK (&deposit2.merchant_pub); /* should fail if merchant is different */
  FAILIF (GNUNET_NO != TALER_MINT_DB_have_deposit (db, &deposit2));
  (void) memcpy (&deposit2.merchant_pub, &deposit.merchant_pub, sizeof (deposit.merchant_pub));
  RND_BLK (&deposit2.coin.coin_pub); /* should fail if coin is different */
  FAILIF (GNUNET_NO != TALER_MINT_DB_have_deposit (db, &deposit2));
  result = 0;

 drop:
  if (NULL != wire)
    json_decref (wire);
  if (NULL != rh)
    TALER_MINT_DB_free_reserve_history (rh);
  rh = NULL;
  if (NULL != db)
    GNUNET_break (GNUNET_OK == TALER_MINT_DB_drop_temporary (db));
  if (NULL != dkp)
    destroy_denon_key_pair (dkp);
  if (NULL != cbc.sig)
    GNUNET_CRYPTO_rsa_signature_free (cbc.sig);
  if (NULL != cbc2.denom_pub)
    GNUNET_CRYPTO_rsa_public_key_free (cbc2.denom_pub);
  if (NULL != cbc2.sig)
    GNUNET_CRYPTO_rsa_signature_free (cbc2.sig);
  dkp = NULL;
}


int
main (int argc, char *const argv[])
{
   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_OPTION_END
  };

   result = -1;
  if (GNUNET_OK !=
      GNUNET_PROGRAM_run (argc, argv,
                          "test-mint-db",
                          "Test cases for mint database helper functions.",
                          options, &run, NULL))
    return 3;
  return result;
}