taler/exchange
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

kill another FIXME

Browse Source
This commit is contained in:
Christian Grothoff 2020-01-16 23:49:34 +01:00
parent 0305cf5f9e
commit d61c2e400a
No known key found for this signature in database
GPG Key ID: 939E6BE1E29FC3CC
12 changed files with 434 additions and 259 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
src/auditor/taler-auditor.c
View File

@ -2274,7 +2274,7 @@ check_transaction_history_for_deposit (const struct
} }
break; break;
case TALER_EXCHANGEDB_TT_REFRESH_MELT: case TALER_EXCHANGEDB_TT_REFRESH_MELT:
amount_with_fee = &tl->details.melt->session.amount_with_fee; amount_with_fee = &tl->details.melt->amount_with_fee;
fee = &tl->details.melt->melt_fee; fee = &tl->details.melt->melt_fee;
fee_dki = &issue->fee_refresh; fee_dki = &issue->fee_refresh;
if (GNUNET_OK != if (GNUNET_OK !=
@ -2489,7 +2489,7 @@ wire_transfer_information_cb (void *cls,
struct TALER_Amount computed_value; struct TALER_Amount computed_value;
struct TALER_Amount coin_value_without_fee; struct TALER_Amount coin_value_without_fee;
struct TALER_EXCHANGEDB_TransactionList *tl; struct TALER_EXCHANGEDB_TransactionList *tl;
const struct TALER_CoinPublicInfo *coin; struct TALER_CoinPublicInfo coin;
enum GNUNET_DB_QueryStatus qs; enum GNUNET_DB_QueryStatus qs;
struct GNUNET_HashCode hw; struct GNUNET_HashCode hw;
@ -2525,36 +2525,26 @@ wire_transfer_information_cb (void *cls,
"no transaction history for coin claimed in aggregation"); "no transaction history for coin claimed in aggregation");
return; return;
} }
qs = edb->get_known_coin (edb->cls,
/* Obtain general denomination information about the coin */ esession,
coin = NULL; coin_pub,
switch (tl->type) &coin);
if (qs < 0)
{ {
case TALER_EXCHANGEDB_TT_DEPOSIT: GNUNET_break (0); /* this should be a foreign key violation at this point! */
coin = &tl->details.deposit->coin; wcc->qs = qs;
break; report_row_inconsistency ("aggregation",
case TALER_EXCHANGEDB_TT_REFRESH_MELT: rowid,
coin = &tl->details.melt->session.coin; "could not get coin details for coin claimed in aggregation");
break; return;
case TALER_EXCHANGEDB_TT_REFUND:
coin = &tl->details.refund->coin;
break;
case TALER_EXCHANGEDB_TT_OLD_COIN_PAYBACK:
coin = &tl->details.payback_refresh->coin;
break;
case TALER_EXCHANGEDB_TT_PAYBACK:
coin = &tl->details.payback->coin;
break;
case TALER_EXCHANGEDB_TT_PAYBACK_REFRESH:
coin = &tl->details.payback_refresh->coin;
break;
} }
GNUNET_assert (NULL != coin); /* hard check that switch worked */
qs = get_denomination_info_by_hash (&coin->denom_pub_hash, qs = get_denomination_info_by_hash (&coin.denom_pub_hash,
&issue); &issue);
if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != qs) if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != qs)
{ {
GNUNET_break (GNUNET_DB_STATUS_SOFT_ERROR == qs); GNUNET_break (GNUNET_DB_STATUS_SOFT_ERROR == qs);
GNUNET_CRYPTO_rsa_signature_free (coin.denom_sig.rsa_signature);
edb->free_coin_transaction_list (edb->cls, edb->free_coin_transaction_list (edb->cls,
tl); tl);
wcc->qs = qs; wcc->qs = qs;
@ -2564,7 +2554,7 @@ wire_transfer_information_cb (void *cls,
return; return;
} }
if (GNUNET_OK != if (GNUNET_OK !=
TALER_test_coin_valid (coin, TALER_test_coin_valid (&coin,
denom_pub)) denom_pub))
{ {
report (report_bad_sig_losses, report (report_bad_sig_losses,
@ -2578,7 +2568,7 @@ wire_transfer_information_cb (void *cls,
TALER_amount_add (&total_bad_sig_loss, TALER_amount_add (&total_bad_sig_loss,
&total_bad_sig_loss, &total_bad_sig_loss,
coin_value)); coin_value));
GNUNET_CRYPTO_rsa_signature_free (coin.denom_sig.rsa_signature);
edb->free_coin_transaction_list (edb->cls, edb->free_coin_transaction_list (edb->cls,
tl); tl);
wcc->qs = GNUNET_DB_STATUS_HARD_ERROR; wcc->qs = GNUNET_DB_STATUS_HARD_ERROR;
@ -2587,7 +2577,8 @@ wire_transfer_information_cb (void *cls,
"coin denomination signature invalid"); "coin denomination signature invalid");
return; return;
} }
GNUNET_CRYPTO_rsa_signature_free (coin.denom_sig.rsa_signature);
coin.denom_sig.rsa_signature = NULL; /* just to be sure */
GNUNET_assert (NULL != issue); /* mostly to help static analysis */ GNUNET_assert (NULL != issue); /* mostly to help static analysis */
/* Check transaction history to see if it supports aggregate /* Check transaction history to see if it supports aggregate
valuation */ valuation */

2
src/exchange/taler-exchange-httpd_deposit.c
View File

@ -214,6 +214,8 @@ deposit_transaction (void *cls,
"Deposited coin has insufficient funds left!\n"); "Deposited coin has insufficient funds left!\n");
*mhd_ret = TEH_RESPONSE_reply_coin_insufficient_funds (connection, *mhd_ret = TEH_RESPONSE_reply_coin_insufficient_funds (connection,
TALER_EC_DEPOSIT_INSUFFICIENT_FUNDS, TALER_EC_DEPOSIT_INSUFFICIENT_FUNDS,
&deposit->coin.
coin_pub,
tl); tl);
TEH_plugin->free_coin_transaction_list (TEH_plugin->cls, TEH_plugin->free_coin_transaction_list (TEH_plugin->cls,
tl); tl);

1
src/exchange/taler-exchange-httpd_payback.c
View File

@ -346,6 +346,7 @@ payback_transaction (void *cls,
session); session);
*mhd_ret = TEH_RESPONSE_reply_coin_insufficient_funds (connection, *mhd_ret = TEH_RESPONSE_reply_coin_insufficient_funds (connection,
TALER_EC_PAYBACK_COIN_BALANCE_ZERO, TALER_EC_PAYBACK_COIN_BALANCE_ZERO,
&pc->coin->coin_pub,
tl); tl);
TEH_plugin->free_coin_transaction_list (TEH_plugin->cls, TEH_plugin->free_coin_transaction_list (TEH_plugin->cls,
tl); tl);

3
src/exchange/taler-exchange-httpd_refresh_melt.c
View File

@ -59,7 +59,8 @@ reply_refresh_melt_insufficient_funds (struct MHD_Connection *connection,
{ {
json_t *history; json_t *history;
history = TEH_RESPONSE_compile_transaction_history (tl); history = TEH_RESPONSE_compile_transaction_history (coin_pub,
tl);
if (NULL == history) if (NULL == history)
return TALER_MHD_reply_with_error (connection, return TALER_MHD_reply_with_error (connection,
MHD_HTTP_INTERNAL_SERVER_ERROR, MHD_HTTP_INTERNAL_SERVER_ERROR,

118
src/exchange/taler-exchange-httpd_refund.c
View File

@ -40,12 +40,14 @@
* Generate successful refund confirmation message. * Generate successful refund confirmation message.
* *
* @param connection connection to the client * @param connection connection to the client
* @param coin_pub public key of the coin
* @param refund details about the successful refund * @param refund details about the successful refund
* @return MHD result code * @return MHD result code
*/ */
static int static int
reply_refund_success (struct MHD_Connection *connection, reply_refund_success (struct MHD_Connection *connection,
const struct TALER_EXCHANGEDB_Refund *refund) const struct TALER_CoinSpendPublicKeyP *coin_pub,
const struct TALER_EXCHANGEDB_RefundListEntry *refund)
{ {
struct TALER_RefundConfirmationPS rc; struct TALER_RefundConfirmationPS rc;
struct TALER_ExchangePublicKeyP pub; struct TALER_ExchangePublicKeyP pub;
@ -54,7 +56,7 @@ reply_refund_success (struct MHD_Connection *connection,
rc.purpose.purpose = htonl (TALER_SIGNATURE_EXCHANGE_CONFIRM_REFUND); rc.purpose.purpose = htonl (TALER_SIGNATURE_EXCHANGE_CONFIRM_REFUND);
rc.purpose.size = htonl (sizeof (struct TALER_RefundConfirmationPS)); rc.purpose.size = htonl (sizeof (struct TALER_RefundConfirmationPS));
rc.h_contract_terms = refund->h_contract_terms; rc.h_contract_terms = refund->h_contract_terms;
rc.coin_pub = refund->coin.coin_pub; rc.coin_pub = *coin_pub;
rc.merchant = refund->merchant_pub; rc.merchant = refund->merchant_pub;
rc.rtransaction_id = GNUNET_htonll (refund->rtransaction_id); rc.rtransaction_id = GNUNET_htonll (refund->rtransaction_id);
TALER_amount_hton (&rc.refund_amount, TALER_amount_hton (&rc.refund_amount,
@ -107,11 +109,13 @@ reply_refund_failure (struct MHD_Connection *connection,
* transaction list @a tl with the details about the conflict. * transaction list @a tl with the details about the conflict.
* *
* @param connection connection to the client * @param connection connection to the client
* @param coin_pub public key this is about
* @param tl transaction list showing the conflict * @param tl transaction list showing the conflict
* @return MHD result code * @return MHD result code
*/ */
static int static int
reply_refund_conflict (struct MHD_Connection *connection, reply_refund_conflict (struct MHD_Connection *connection,
const struct TALER_CoinSpendPublicKeyP *coin_pub,
const struct TALER_EXCHANGEDB_TransactionList *tl) const struct TALER_EXCHANGEDB_TransactionList *tl)
{ {
return TALER_MHD_reply_json_pack (connection, return TALER_MHD_reply_json_pack (connection,
@ -122,6 +126,7 @@ reply_refund_conflict (struct MHD_Connection *connection,
(json_int_t) TALER_EC_REFUND_CONFLICT, (json_int_t) TALER_EC_REFUND_CONFLICT,
"history", "history",
TEH_RESPONSE_compile_transaction_history ( TEH_RESPONSE_compile_transaction_history (
coin_pub,
tl)); tl));
} }
@ -152,8 +157,8 @@ refund_transaction (void *cls,
{ {
const struct TALER_EXCHANGEDB_Refund *refund = cls; const struct TALER_EXCHANGEDB_Refund *refund = cls;
struct TALER_EXCHANGEDB_TransactionList *tl; struct TALER_EXCHANGEDB_TransactionList *tl;
const struct TALER_EXCHANGEDB_Deposit *dep; const struct TALER_EXCHANGEDB_DepositListEntry *dep;
const struct TALER_EXCHANGEDB_Refund *ref; const struct TALER_EXCHANGEDB_RefundListEntry *ref;
struct TEH_KS_StateHandle *mks; struct TEH_KS_StateHandle *mks;
struct TALER_EXCHANGEDB_DenominationKeyIssueInformation *dki; struct TALER_EXCHANGEDB_DenominationKeyIssueInformation *dki;
struct TALER_Amount expect_fee; struct TALER_Amount expect_fee;
@ -163,6 +168,7 @@ refund_transaction (void *cls,
int fee_cmp; int fee_cmp;
unsigned int hc; unsigned int hc;
enum TALER_ErrorCode ec; enum TALER_ErrorCode ec;
struct TALER_CoinPublicInfo coin_info;
dep = NULL; dep = NULL;
ref = NULL; ref = NULL;
@ -192,10 +198,10 @@ refund_transaction (void *cls,
if (GNUNET_NO == deposit_found) if (GNUNET_NO == deposit_found)
{ {
if ( (0 == memcmp (&tlp->details.deposit->merchant_pub, if ( (0 == memcmp (&tlp->details.deposit->merchant_pub,
&refund->merchant_pub, &refund->details.merchant_pub,
sizeof (struct TALER_MerchantPublicKeyP))) && sizeof (struct TALER_MerchantPublicKeyP))) &&
(0 == memcmp (&tlp->details.deposit->h_contract_terms, (0 == memcmp (&tlp->details.deposit->h_contract_terms,
&refund->h_contract_terms, &refund->details.h_contract_terms,
sizeof (struct GNUNET_HashCode))) ) sizeof (struct GNUNET_HashCode))) )
{ {
dep = tlp->details.deposit; dep = tlp->details.deposit;
@ -212,12 +218,13 @@ refund_transaction (void *cls,
{ {
/* First, check if existing refund request is identical */ /* First, check if existing refund request is identical */
if ( (0 == memcmp (&tlp->details.refund->merchant_pub, if ( (0 == memcmp (&tlp->details.refund->merchant_pub,
&refund->merchant_pub, &refund->details.merchant_pub,
sizeof (struct TALER_MerchantPublicKeyP))) && sizeof (struct TALER_MerchantPublicKeyP))) &&
(0 == memcmp (&tlp->details.refund->h_contract_terms, (0 == memcmp (&tlp->details.refund->h_contract_terms,
&refund->h_contract_terms, &refund->details.h_contract_terms,
sizeof (struct GNUNET_HashCode))) && sizeof (struct GNUNET_HashCode))) &&
(tlp->details.refund->rtransaction_id == refund->rtransaction_id) ) (tlp->details.refund->rtransaction_id ==
refund->details.rtransaction_id) )
{ {
ref = tlp->details.refund; ref = tlp->details.refund;
refund_found = GNUNET_YES; refund_found = GNUNET_YES;
@ -225,12 +232,13 @@ refund_transaction (void *cls,
} }
/* Second, check if existing refund request conflicts */ /* Second, check if existing refund request conflicts */
if ( (0 == memcmp (&tlp->details.refund->merchant_pub, if ( (0 == memcmp (&tlp->details.refund->merchant_pub,
&refund->merchant_pub, &refund->details.merchant_pub,
sizeof (struct TALER_MerchantPublicKeyP))) && sizeof (struct TALER_MerchantPublicKeyP))) &&
(0 == memcmp (&tlp->details.refund->h_contract_terms, (0 == memcmp (&tlp->details.refund->h_contract_terms,
&refund->h_contract_terms, &refund->details.h_contract_terms,
sizeof (struct GNUNET_HashCode))) && sizeof (struct GNUNET_HashCode))) &&
(tlp->details.refund->rtransaction_id != refund->rtransaction_id) ) (tlp->details.refund->rtransaction_id !=
refund->details.rtransaction_id) )
{ {
GNUNET_break_op (0); /* conflicting refund found */ GNUNET_break_op (0); /* conflicting refund found */
refund_found = GNUNET_SYSERR; refund_found = GNUNET_SYSERR;
@ -269,6 +277,7 @@ refund_transaction (void *cls,
if (GNUNET_SYSERR == refund_found) if (GNUNET_SYSERR == refund_found)
{ {
*mhd_ret = reply_refund_conflict (connection, *mhd_ret = reply_refund_conflict (connection,
&refund->coin.coin_pub,
tl); tl);
TEH_plugin->free_coin_transaction_list (TEH_plugin->cls, TEH_plugin->free_coin_transaction_list (TEH_plugin->cls,
tl); tl);
@ -279,6 +288,7 @@ refund_transaction (void *cls,
{ {
/* /refund already done, simply re-transmit confirmation */ /* /refund already done, simply re-transmit confirmation */
*mhd_ret = reply_refund_success (connection, *mhd_ret = reply_refund_success (connection,
&refund->coin.coin_pub,
ref); ref);
TEH_plugin->free_coin_transaction_list (TEH_plugin->cls, TEH_plugin->free_coin_transaction_list (TEH_plugin->cls,
tl); tl);
@ -287,10 +297,10 @@ refund_transaction (void *cls,
/* check currency is compatible */ /* check currency is compatible */
if ( (GNUNET_YES != if ( (GNUNET_YES !=
TALER_amount_cmp_currency (&refund->refund_amount, TALER_amount_cmp_currency (&refund->details.refund_amount,
&dep->amount_with_fee)) || &dep->amount_with_fee)) ||
(GNUNET_YES != (GNUNET_YES !=
TALER_amount_cmp_currency (&refund->refund_fee, TALER_amount_cmp_currency (&refund->details.refund_fee,
&dep->deposit_fee)) ) &dep->deposit_fee)) )
{ {
GNUNET_break_op (0); /* currency missmatch */ GNUNET_break_op (0); /* currency missmatch */
@ -303,7 +313,10 @@ refund_transaction (void *cls,
/* check if we already send the money for the /deposit */ /* check if we already send the money for the /deposit */
qs = TEH_plugin->test_deposit_done (TEH_plugin->cls, qs = TEH_plugin->test_deposit_done (TEH_plugin->cls,
session, session,
dep); &refund->coin.coin_pub,
&dep->merchant_pub,
&dep->h_contract_terms,
&dep->h_wire);
if (GNUNET_DB_STATUS_HARD_ERROR == qs) if (GNUNET_DB_STATUS_HARD_ERROR == qs)
{ {
/* Internal error, we first had the deposit in the history, /* Internal error, we first had the deposit in the history,
@ -332,7 +345,7 @@ refund_transaction (void *cls,
} }
/* check refund amount is sufficiently low */ /* check refund amount is sufficiently low */
if (1 == TALER_amount_cmp (&refund->refund_amount, if (1 == TALER_amount_cmp (&refund->details.refund_amount,
&dep->amount_with_fee) ) &dep->amount_with_fee) )
{ {
GNUNET_break_op (0); /* cannot refund more than original value */ GNUNET_break_op (0); /* cannot refund more than original value */
@ -343,7 +356,25 @@ refund_transaction (void *cls,
TALER_EC_REFUND_INSUFFICIENT_FUNDS); TALER_EC_REFUND_INSUFFICIENT_FUNDS);
return GNUNET_DB_STATUS_HARD_ERROR; return GNUNET_DB_STATUS_HARD_ERROR;
} }
qs = TEH_plugin->get_known_coin (TEH_plugin->cls,
session,
&refund->coin.coin_pub,
&coin_info);
if (0 > qs)
{
TEH_plugin->free_coin_transaction_list (TEH_plugin->cls,
tl);
if (GNUNET_DB_STATUS_HARD_ERROR == qs)
{
GNUNET_break (0); /* should be impossible by foreign key constraint! */
*mhd_ret = reply_refund_failure (connection,
MHD_HTTP_NOT_FOUND,
TALER_EC_REFUND_COIN_NOT_FOUND);
}
return qs;
}
GNUNET_CRYPTO_rsa_signature_free (coin_info.denom_sig.rsa_signature);
coin_info.denom_sig.rsa_signature = NULL; /* just to be safe */
// FIXME: do this outside of transaction function? // FIXME: do this outside of transaction function?
/* Check refund fee matches fee of denomination key! */ /* Check refund fee matches fee of denomination key! */
mks = TEH_KS_acquire (GNUNET_TIME_absolute_get ()); mks = TEH_KS_acquire (GNUNET_TIME_absolute_get ());
@ -359,7 +390,7 @@ refund_transaction (void *cls,
return GNUNET_DB_STATUS_HARD_ERROR; return GNUNET_DB_STATUS_HARD_ERROR;
} }
dki = TEH_KS_denomination_key_lookup_by_hash (mks, dki = TEH_KS_denomination_key_lookup_by_hash (mks,
&dep->coin.denom_pub_hash, &coin_info.denom_pub_hash,
TEH_KS_DKU_DEPOSIT, TEH_KS_DKU_DEPOSIT,
&ec, &ec,
&hc); &hc);
@ -379,7 +410,7 @@ refund_transaction (void *cls,
} }
TALER_amount_ntoh (&expect_fee, TALER_amount_ntoh (&expect_fee,
&dki->issue.properties.fee_refund); &dki->issue.properties.fee_refund);
fee_cmp = TALER_amount_cmp (&refund->refund_fee, fee_cmp = TALER_amount_cmp (&refund->details.refund_fee,
&expect_fee); &expect_fee);
TEH_KS_release (mks); TEH_KS_release (mks);
@ -436,19 +467,9 @@ verify_and_execute_refund (struct MHD_Connection *connection,
struct TALER_RefundRequestPS rr; struct TALER_RefundRequestPS rr;
int mhd_ret; int mhd_ret;
rr.purpose.purpose = htonl (TALER_SIGNATURE_MERCHANT_REFUND);
rr.purpose.size = htonl (sizeof (struct TALER_RefundRequestPS));
rr.h_contract_terms = refund->h_contract_terms;
rr.coin_pub = refund->coin.coin_pub;
rr.merchant = refund->merchant_pub;
rr.rtransaction_id = GNUNET_htonll (refund->rtransaction_id);
TALER_amount_hton (&rr.refund_amount,
&refund->refund_amount);
TALER_amount_hton (&rr.refund_fee,
&refund->refund_fee);
if (GNUNET_YES != if (GNUNET_YES !=
TALER_amount_cmp_currency (&refund->refund_amount, TALER_amount_cmp_currency (&refund->details.refund_amount,
&refund->refund_fee) ) &refund->details.refund_fee) )
{ {
GNUNET_break_op (0); GNUNET_break_op (0);
return TALER_MHD_reply_with_error (connection, return TALER_MHD_reply_with_error (connection,
@ -456,8 +477,8 @@ verify_and_execute_refund (struct MHD_Connection *connection,
TALER_EC_REFUND_FEE_CURRENCY_MISSMATCH, TALER_EC_REFUND_FEE_CURRENCY_MISSMATCH,
"refund_fee"); "refund_fee");
} }
if (-1 == TALER_amount_cmp (&refund->refund_amount, if (-1 == TALER_amount_cmp (&refund->details.refund_amount,
&refund->refund_fee) ) &refund->details.refund_fee) )
{ {
GNUNET_break_op (0); GNUNET_break_op (0);
return TALER_MHD_reply_with_error (connection, return TALER_MHD_reply_with_error (connection,
@ -465,11 +486,21 @@ verify_and_execute_refund (struct MHD_Connection *connection,
TALER_EC_REFUND_FEE_ABOVE_AMOUNT, TALER_EC_REFUND_FEE_ABOVE_AMOUNT,
"refund_amount"); "refund_amount");
} }
rr.purpose.purpose = htonl (TALER_SIGNATURE_MERCHANT_REFUND);
rr.purpose.size = htonl (sizeof (struct TALER_RefundRequestPS));
rr.h_contract_terms = refund->details.h_contract_terms;
rr.coin_pub = refund->coin.coin_pub;
rr.merchant = refund->details.merchant_pub;
rr.rtransaction_id = GNUNET_htonll (refund->details.rtransaction_id);
TALER_amount_hton (&rr.refund_amount,
&refund->details.refund_amount);
TALER_amount_hton (&rr.refund_fee,
&refund->details.refund_fee);
if (GNUNET_OK != if (GNUNET_OK !=
GNUNET_CRYPTO_eddsa_verify (TALER_SIGNATURE_MERCHANT_REFUND, GNUNET_CRYPTO_eddsa_verify (TALER_SIGNATURE_MERCHANT_REFUND,
&rr.purpose, &rr.purpose,
&refund->merchant_sig.eddsa_sig, &refund->details.merchant_sig.eddsa_sig,
&refund->merchant_pub.eddsa_pub)) &refund->details.merchant_pub.eddsa_pub))
{ {
TALER_LOG_WARNING ("Invalid signature on /refund request\n"); TALER_LOG_WARNING ("Invalid signature on /refund request\n");
return TALER_MHD_reply_with_error (connection, return TALER_MHD_reply_with_error (connection,
@ -485,7 +516,8 @@ verify_and_execute_refund (struct MHD_Connection *connection,
(void *) refund)) (void *) refund))
return mhd_ret; return mhd_ret;
return reply_refund_success (connection, return reply_refund_success (connection,
refund); &refund->coin.coin_pub,
&refund->details);
} }
@ -514,13 +546,15 @@ TEH_REFUND_handler_refund (struct TEH_RequestHandler *rh,
int res; int res;
struct TALER_EXCHANGEDB_Refund refund; struct TALER_EXCHANGEDB_Refund refund;
struct GNUNET_JSON_Specification spec[] = { struct GNUNET_JSON_Specification spec[] = {
TALER_JSON_spec_amount ("refund_amount", &refund.refund_amount), TALER_JSON_spec_amount ("refund_amount", &refund.details.refund_amount),
TALER_JSON_spec_amount ("refund_fee", &refund.refund_fee), TALER_JSON_spec_amount ("refund_fee", &refund.details.refund_fee),
GNUNET_JSON_spec_fixed_auto ("h_contract_terms", &refund.h_contract_terms), GNUNET_JSON_spec_fixed_auto ("h_contract_terms",
&refund.details.h_contract_terms),
GNUNET_JSON_spec_fixed_auto ("coin_pub", &refund.coin.coin_pub), GNUNET_JSON_spec_fixed_auto ("coin_pub", &refund.coin.coin_pub),
GNUNET_JSON_spec_fixed_auto ("merchant_pub", &refund.merchant_pub), GNUNET_JSON_spec_fixed_auto ("merchant_pub", &refund.details.merchant_pub),
GNUNET_JSON_spec_uint64 ("rtransaction_id", &refund.rtransaction_id), GNUNET_JSON_spec_uint64 ("rtransaction_id",
GNUNET_JSON_spec_fixed_auto ("merchant_sig", &refund.merchant_sig), &refund.details.rtransaction_id),
GNUNET_JSON_spec_fixed_auto ("merchant_sig", &refund.details.merchant_sig),
GNUNET_JSON_spec_end () GNUNET_JSON_spec_end ()
}; };

53
src/exchange/taler-exchange-httpd_responses.c
View File

@ -42,11 +42,14 @@
/** /**
* Compile the transaction history of a coin into a JSON object. * Compile the transaction history of a coin into a JSON object.
* *
* @param coin_pub public key of the coin
* @param tl transaction history to JSON-ify * @param tl transaction history to JSON-ify
* @return json representation of the @a rh, NULL on error * @return json representation of the @a rh, NULL on error
*/ */
json_t * json_t *
TEH_RESPONSE_compile_transaction_history (const struct TEH_RESPONSE_compile_transaction_history (const struct
TALER_CoinSpendPublicKeyP *coin_pub,
const struct
TALER_EXCHANGEDB_TransactionList *tl) TALER_EXCHANGEDB_TransactionList *tl)
{ {
json_t *history; json_t *history;
@ -66,7 +69,8 @@ TEH_RESPONSE_compile_transaction_history (const struct
case TALER_EXCHANGEDB_TT_DEPOSIT: case TALER_EXCHANGEDB_TT_DEPOSIT:
{ {
struct TALER_DepositRequestPS dr; struct TALER_DepositRequestPS dr;
const struct TALER_EXCHANGEDB_Deposit *deposit = pos->details.deposit; const struct TALER_EXCHANGEDB_DepositListEntry *deposit =
pos->details.deposit;
dr.purpose.purpose = htonl (TALER_SIGNATURE_WALLET_COIN_DEPOSIT); dr.purpose.purpose = htonl (TALER_SIGNATURE_WALLET_COIN_DEPOSIT);
dr.purpose.size = htonl (sizeof (struct TALER_DepositRequestPS)); dr.purpose.size = htonl (sizeof (struct TALER_DepositRequestPS));
@ -80,14 +84,14 @@ TEH_RESPONSE_compile_transaction_history (const struct
TALER_amount_hton (&dr.deposit_fee, TALER_amount_hton (&dr.deposit_fee,
&deposit->deposit_fee); &deposit->deposit_fee);
dr.merchant = deposit->merchant_pub; dr.merchant = deposit->merchant_pub;
dr.coin_pub = deposit->coin.coin_pub; dr.coin_pub = *coin_pub;
#if SANITY_CHECKS_ON #if SANITY_CHECKS_ON
/* internal sanity check before we hand out a bogus sig... */ /* internal sanity check before we hand out a bogus sig... */
if (GNUNET_OK != if (GNUNET_OK !=
GNUNET_CRYPTO_eddsa_verify (TALER_SIGNATURE_WALLET_COIN_DEPOSIT, GNUNET_CRYPTO_eddsa_verify (TALER_SIGNATURE_WALLET_COIN_DEPOSIT,
&dr.purpose, &dr.purpose,
&deposit->csig.eddsa_signature, &deposit->csig.eddsa_signature,
&deposit->coin.coin_pub.eddsa_pub)) &coin_pub->eddsa_pub))
{ {
GNUNET_break (0); GNUNET_break (0);
json_decref (history); json_decref (history);
@ -132,24 +136,25 @@ TEH_RESPONSE_compile_transaction_history (const struct
case TALER_EXCHANGEDB_TT_REFRESH_MELT: case TALER_EXCHANGEDB_TT_REFRESH_MELT:
{ {
struct TALER_RefreshMeltCoinAffirmationPS ms; struct TALER_RefreshMeltCoinAffirmationPS ms;
const struct TALER_EXCHANGEDB_RefreshMelt *melt = pos->details.melt; const struct TALER_EXCHANGEDB_RefreshMeltListEntry *melt =
pos->details.melt;
ms.purpose.purpose = htonl (TALER_SIGNATURE_WALLET_COIN_MELT); ms.purpose.purpose = htonl (TALER_SIGNATURE_WALLET_COIN_MELT);
ms.purpose.size = htonl (sizeof (struct ms.purpose.size = htonl (sizeof (struct
TALER_RefreshMeltCoinAffirmationPS)); TALER_RefreshMeltCoinAffirmationPS));
ms.rc = melt->session.rc; ms.rc = melt->rc;
TALER_amount_hton (&ms.amount_with_fee, TALER_amount_hton (&ms.amount_with_fee,
&melt->session.amount_with_fee); &melt->amount_with_fee);
TALER_amount_hton (&ms.melt_fee, TALER_amount_hton (&ms.melt_fee,
&melt->melt_fee); &melt->melt_fee);
ms.coin_pub = melt->session.coin.coin_pub; ms.coin_pub = *coin_pub;
#if SANITY_CHECKS_ON #if SANITY_CHECKS_ON
/* internal sanity check before we hand out a bogus sig... */ /* internal sanity check before we hand out a bogus sig... */
if (GNUNET_OK != if (GNUNET_OK !=
GNUNET_CRYPTO_eddsa_verify (TALER_SIGNATURE_WALLET_COIN_MELT, GNUNET_CRYPTO_eddsa_verify (TALER_SIGNATURE_WALLET_COIN_MELT,
&ms.purpose, &ms.purpose,
&melt->session.coin_sig.eddsa_signature, &melt->coin_sig.eddsa_signature,
&melt->session.coin.coin_pub.eddsa_pub)) &coin_pub->eddsa_pub))
{ {
GNUNET_break (0); GNUNET_break (0);
json_decref (history); json_decref (history);
@ -161,15 +166,15 @@ TEH_RESPONSE_compile_transaction_history (const struct
json_pack ("{s:s, s:o, s:o, s:o, s:o}", json_pack ("{s:s, s:o, s:o, s:o, s:o}",
"type", "MELT", "type", "MELT",
"amount", TALER_JSON_from_amount ( "amount", TALER_JSON_from_amount (
&melt->session.amount_with_fee), &melt->amount_with_fee),
"melt_fee", "melt_fee",
TALER_JSON_from_amount ( TALER_JSON_from_amount (
&melt->melt_fee), &melt->melt_fee),
"rc", GNUNET_JSON_from_data_auto ( "rc", GNUNET_JSON_from_data_auto (
&melt->session.rc), &melt->rc),
"coin_sig", "coin_sig",
GNUNET_JSON_from_data_auto ( GNUNET_JSON_from_data_auto (
&melt->session.coin_sig)))) &melt->coin_sig))))
{ {
GNUNET_break (0); GNUNET_break (0);
json_decref (history); json_decref (history);
@ -180,7 +185,8 @@ TEH_RESPONSE_compile_transaction_history (const struct
case TALER_EXCHANGEDB_TT_REFUND: case TALER_EXCHANGEDB_TT_REFUND:
{ {
struct TALER_RefundRequestPS rr; struct TALER_RefundRequestPS rr;
const struct TALER_EXCHANGEDB_Refund *refund = pos->details.refund; const struct TALER_EXCHANGEDB_RefundListEntry *refund =
pos->details.refund;
struct TALER_Amount value; struct TALER_Amount value;
if (GNUNET_OK != if (GNUNET_OK !=
@ -195,7 +201,7 @@ TEH_RESPONSE_compile_transaction_history (const struct
rr.purpose.purpose = htonl (TALER_SIGNATURE_MERCHANT_REFUND); rr.purpose.purpose = htonl (TALER_SIGNATURE_MERCHANT_REFUND);
rr.purpose.size = htonl (sizeof (struct TALER_RefundRequestPS)); rr.purpose.size = htonl (sizeof (struct TALER_RefundRequestPS));
rr.h_contract_terms = refund->h_contract_terms; rr.h_contract_terms = refund->h_contract_terms;
rr.coin_pub = refund->coin.coin_pub; rr.coin_pub = *coin_pub;
rr.merchant = refund->merchant_pub; rr.merchant = refund->merchant_pub;
rr.rtransaction_id = GNUNET_htonll (refund->rtransaction_id); rr.rtransaction_id = GNUNET_htonll (refund->rtransaction_id);
TALER_amount_hton (&rr.refund_amount, TALER_amount_hton (&rr.refund_amount,
@ -245,7 +251,7 @@ TEH_RESPONSE_compile_transaction_history (const struct
break; break;
case TALER_EXCHANGEDB_TT_OLD_COIN_PAYBACK: case TALER_EXCHANGEDB_TT_OLD_COIN_PAYBACK:
{ {
struct TALER_EXCHANGEDB_PaybackRefresh *pr = struct TALER_EXCHANGEDB_PaybackRefreshListEntry *pr =
pos->details.old_coin_payback; pos->details.old_coin_payback;
struct TALER_PaybackRefreshConfirmationPS pc; struct TALER_PaybackRefreshConfirmationPS pc;
struct TALER_ExchangePublicKeyP epub; struct TALER_ExchangePublicKeyP epub;
@ -257,7 +263,7 @@ TEH_RESPONSE_compile_transaction_history (const struct
pc.timestamp = GNUNET_TIME_absolute_hton (pr->timestamp); pc.timestamp = GNUNET_TIME_absolute_hton (pr->timestamp);
TALER_amount_hton (&pc.payback_amount, TALER_amount_hton (&pc.payback_amount,
&pr->value); &pr->value);
pc.coin_pub = pr->coin.coin_pub; pc.coin_pub = *coin_pub;
pc.old_coin_pub = pr->old_coin_pub; pc.old_coin_pub = pr->old_coin_pub;
if (GNUNET_OK != if (GNUNET_OK !=
TEH_KS_sign (&pc.purpose, TEH_KS_sign (&pc.purpose,
@ -299,7 +305,8 @@ TEH_RESPONSE_compile_transaction_history (const struct
} }
case TALER_EXCHANGEDB_TT_PAYBACK: case TALER_EXCHANGEDB_TT_PAYBACK:
{ {
const struct TALER_EXCHANGEDB_Payback *payback = pos->details.payback; const struct TALER_EXCHANGEDB_PaybackListEntry *payback =
pos->details.payback;
struct TALER_PaybackConfirmationPS pc; struct TALER_PaybackConfirmationPS pc;
struct TALER_ExchangePublicKeyP epub; struct TALER_ExchangePublicKeyP epub;
struct TALER_ExchangeSignatureP esig; struct TALER_ExchangeSignatureP esig;
@ -309,7 +316,7 @@ TEH_RESPONSE_compile_transaction_history (const struct
pc.timestamp = GNUNET_TIME_absolute_hton (payback->timestamp); pc.timestamp = GNUNET_TIME_absolute_hton (payback->timestamp);
TALER_amount_hton (&pc.payback_amount, TALER_amount_hton (&pc.payback_amount,
&payback->value); &payback->value);
pc.coin_pub = payback->coin.coin_pub; pc.coin_pub = *coin_pub;
pc.reserve_pub = payback->reserve_pub; pc.reserve_pub = payback->reserve_pub;
if (GNUNET_OK != if (GNUNET_OK !=
TEH_KS_sign (&pc.purpose, TEH_KS_sign (&pc.purpose,
@ -347,7 +354,7 @@ TEH_RESPONSE_compile_transaction_history (const struct
break; break;
case TALER_EXCHANGEDB_TT_PAYBACK_REFRESH: case TALER_EXCHANGEDB_TT_PAYBACK_REFRESH:
{ {
struct TALER_EXCHANGEDB_PaybackRefresh *pr = struct TALER_EXCHANGEDB_PaybackRefreshListEntry *pr =
pos->details.payback_refresh; pos->details.payback_refresh;
struct TALER_PaybackRefreshConfirmationPS pc; struct TALER_PaybackRefreshConfirmationPS pc;
struct TALER_ExchangePublicKeyP epub; struct TALER_ExchangePublicKeyP epub;
@ -359,7 +366,7 @@ TEH_RESPONSE_compile_transaction_history (const struct
pc.timestamp = GNUNET_TIME_absolute_hton (pr->timestamp); pc.timestamp = GNUNET_TIME_absolute_hton (pr->timestamp);
TALER_amount_hton (&pc.payback_amount, TALER_amount_hton (&pc.payback_amount,
&pr->value); &pr->value);
pc.coin_pub = pr->coin.coin_pub; pc.coin_pub = *coin_pub;
pc.old_coin_pub = pr->old_coin_pub; pc.old_coin_pub = pr->old_coin_pub;
if (GNUNET_OK != if (GNUNET_OK !=
TEH_KS_sign (&pc.purpose, TEH_KS_sign (&pc.purpose,
@ -415,6 +422,7 @@ TEH_RESPONSE_compile_transaction_history (const struct
* *
* @param connection connection to the client * @param connection connection to the client
* @param ec error code to return * @param ec error code to return
* @param coin_pub public key of the coin
* @param tl transaction list to use to build reply * @param tl transaction list to use to build reply
* @return MHD result code * @return MHD result code
*/ */
@ -422,11 +430,14 @@ int
TEH_RESPONSE_reply_coin_insufficient_funds (struct MHD_Connection *connection, TEH_RESPONSE_reply_coin_insufficient_funds (struct MHD_Connection *connection,
enum TALER_ErrorCode ec, enum TALER_ErrorCode ec,
const struct const struct
TALER_CoinSpendPublicKeyP *coin_pub,
const struct
TALER_EXCHANGEDB_TransactionList *tl) TALER_EXCHANGEDB_TransactionList *tl)
{ {
json_t *history; json_t *history;
history = TEH_RESPONSE_compile_transaction_history (tl); history = TEH_RESPONSE_compile_transaction_history (coin_pub,
tl);
if (NULL == history) if (NULL == history)
return TALER_MHD_reply_with_error (connection, return TALER_MHD_reply_with_error (connection,
MHD_HTTP_INTERNAL_SERVER_ERROR, MHD_HTTP_INTERNAL_SERVER_ERROR,

8
src/exchange/taler-exchange-httpd_responses.h
View File

@ -55,6 +55,7 @@ TEH_RESPONSE_compile_reserve_history (const struct
* *
* @param connection connection to the client * @param connection connection to the client
* @param ec error code to return * @param ec error code to return
* @param coin_pub public key of the coin
* @param tl transaction list to use to build reply * @param tl transaction list to use to build reply
* @return MHD result code * @return MHD result code
*/ */
@ -62,17 +63,22 @@ int
TEH_RESPONSE_reply_coin_insufficient_funds (struct MHD_Connection *connection, TEH_RESPONSE_reply_coin_insufficient_funds (struct MHD_Connection *connection,
enum TALER_ErrorCode ec, enum TALER_ErrorCode ec,
const struct const struct
TALER_CoinSpendPublicKeyP *coin_pub,
const struct
TALER_EXCHANGEDB_TransactionList *tl); TALER_EXCHANGEDB_TransactionList *tl);
/** /**
* Compile the transaction history of a coin into a JSON object. * Compile the transaction history of a coin into a JSON object.
* *
* @param coin_pub public key of the coin
* @param tl transaction history to JSON-ify * @param tl transaction history to JSON-ify
* @return json representation of the @a rh * @return json representation of the @a rh, NULL on error
*/ */
json_t * json_t *
TEH_RESPONSE_compile_transaction_history (const struct TEH_RESPONSE_compile_transaction_history (const struct
TALER_CoinSpendPublicKeyP *coin_pub,
const struct
TALER_EXCHANGEDB_TransactionList *tl); TALER_EXCHANGEDB_TransactionList *tl);

7
src/exchangedb/exchangedb_transactions.c
View File

@ -46,8 +46,9 @@ TALER_EXCHANGEDB_calculate_transaction_list_totals (struct
GNUNET_assert (GNUNET_OK == GNUNET_assert (GNUNET_OK ==
TALER_amount_get_zero (spent.currency, TALER_amount_get_zero (spent.currency,
&refunded)); &refunded));
for (struct TALER_EXCHANGEDB_TransactionList *pos = tl; NULL != pos; pos = for (struct TALER_EXCHANGEDB_TransactionList *pos = tl;
pos->next) NULL != pos;
pos = pos->next)
{ {
switch (pos->type) switch (pos->type)
{ {
@ -67,7 +68,7 @@ TALER_EXCHANGEDB_calculate_transaction_list_totals (struct
if (GNUNET_OK != if (GNUNET_OK !=
TALER_amount_add (&spent, TALER_amount_add (&spent,
&spent, &spent,
&pos->details.melt->session.amount_with_fee)) &pos->details.melt->amount_with_fee))
{ {
GNUNET_break (0); GNUNET_break (0);
return GNUNET_SYSERR; return GNUNET_SYSERR;

12
src/exchangedb/plugin_exchangedb_common.c
View File

@ -92,15 +92,9 @@ common_free_coin_transaction_list (void *cls,
case TALER_EXCHANGEDB_TT_DEPOSIT: case TALER_EXCHANGEDB_TT_DEPOSIT:
if (NULL != list->details.deposit->receiver_wire_account) if (NULL != list->details.deposit->receiver_wire_account)
json_decref (list->details.deposit->receiver_wire_account); json_decref (list->details.deposit->receiver_wire_account);
if (NULL != list->details.deposit->coin.denom_sig.rsa_signature)
GNUNET_CRYPTO_rsa_signature_free (
list->details.deposit->coin.denom_sig.rsa_signature);
GNUNET_free (list->details.deposit); GNUNET_free (list->details.deposit);
break; break;
case TALER_EXCHANGEDB_TT_REFRESH_MELT: case TALER_EXCHANGEDB_TT_REFRESH_MELT:
if (NULL != list->details.melt->session.coin.denom_sig.rsa_signature)
GNUNET_CRYPTO_rsa_signature_free (
list->details.melt->session.coin.denom_sig.rsa_signature);
GNUNET_free (list->details.melt); GNUNET_free (list->details.melt);
break; break;
case TALER_EXCHANGEDB_TT_OLD_COIN_PAYBACK: case TALER_EXCHANGEDB_TT_OLD_COIN_PAYBACK:
@ -110,15 +104,9 @@ common_free_coin_transaction_list (void *cls,
GNUNET_free (list->details.old_coin_payback); GNUNET_free (list->details.old_coin_payback);
break; break;
case TALER_EXCHANGEDB_TT_REFUND: case TALER_EXCHANGEDB_TT_REFUND:
if (NULL != list->details.refund->coin.denom_sig.rsa_signature)
GNUNET_CRYPTO_rsa_signature_free (
list->details.refund->coin.denom_sig.rsa_signature);
GNUNET_free (list->details.refund); GNUNET_free (list->details.refund);
break; break;
case TALER_EXCHANGEDB_TT_PAYBACK: case TALER_EXCHANGEDB_TT_PAYBACK:
if (NULL != list->details.payback->coin.denom_sig.rsa_signature)
GNUNET_CRYPTO_rsa_signature_free (
list->details.payback->coin.denom_sig.rsa_signature);
GNUNET_free (list->details.payback); GNUNET_free (list->details.payback);
break; break;
case TALER_EXCHANGEDB_TT_PAYBACK_REFRESH: case TALER_EXCHANGEDB_TT_PAYBACK_REFRESH:

140
src/exchangedb/plugin_exchangedb_postgres.c
View File

@ -1630,12 +1630,8 @@ postgres_get_session (void *cls)
",amount_val" ",amount_val"
",amount_frac" ",amount_frac"
",timestamp" ",timestamp"
",coins.denom_pub_hash"
",coins.denom_sig"
",payback_uuid" ",payback_uuid"
" FROM payback" " FROM payback"
" JOIN known_coins coins"
" USING (coin_pub)"
" JOIN reserves_out ro" " JOIN reserves_out ro"
" USING (h_blind_ev)" " USING (h_blind_ev)"
" WHERE payback.coin_pub=$1" " WHERE payback.coin_pub=$1"
@ -2982,7 +2978,10 @@ postgres_mark_deposit_tiny (void *cls,
* *
* @param cls the @e cls of this struct with the plugin-specific state * @param cls the @e cls of this struct with the plugin-specific state
* @param session connection to the database * @param session connection to the database
* @param deposit the deposit to check * @param coin_pub the coin to check for deposit
* @param merchant_pub merchant to receive the deposit
* @param h_contract_terms contract terms of the deposit
* @param h_wire hash of the merchant's wire details
* @return #GNUNET_DB_STATUS_SUCCESS_ONE_RESULT if is is marked done, * @return #GNUNET_DB_STATUS_SUCCESS_ONE_RESULT if is is marked done,
* #GNUNET_DB_STATUS_SUCCESS_NO_RESULTS if not, * #GNUNET_DB_STATUS_SUCCESS_NO_RESULTS if not,
* otherwise transaction error status (incl. deposit unknown) * otherwise transaction error status (incl. deposit unknown)
@ -2990,13 +2989,16 @@ postgres_mark_deposit_tiny (void *cls,
static enum GNUNET_DB_QueryStatus static enum GNUNET_DB_QueryStatus
postgres_test_deposit_done (void *cls, postgres_test_deposit_done (void *cls,
struct TALER_EXCHANGEDB_Session *session, struct TALER_EXCHANGEDB_Session *session,
const struct TALER_EXCHANGEDB_Deposit *deposit) const struct TALER_CoinSpendPublicKeyP *coin_pub,
const struct TALER_MerchantPublicKeyP *merchant_pub,
const struct GNUNET_HashCode *h_contract_terms,
const struct GNUNET_HashCode *h_wire)
{ {
struct GNUNET_PQ_QueryParam params[] = { struct GNUNET_PQ_QueryParam params[] = {
GNUNET_PQ_query_param_auto_from_type (&deposit->coin.coin_pub), GNUNET_PQ_query_param_auto_from_type (coin_pub),
GNUNET_PQ_query_param_auto_from_type (&deposit->merchant_pub), GNUNET_PQ_query_param_auto_from_type (merchant_pub),
GNUNET_PQ_query_param_auto_from_type (&deposit->h_contract_terms), GNUNET_PQ_query_param_auto_from_type (h_contract_terms),
GNUNET_PQ_query_param_auto_from_type (&deposit->h_wire), GNUNET_PQ_query_param_auto_from_type (h_wire),
GNUNET_PQ_query_param_end GNUNET_PQ_query_param_end
}; };
uint8_t done = 0; uint8_t done = 0;
@ -3517,18 +3519,18 @@ postgres_insert_refund (void *cls,
{ {
struct GNUNET_PQ_QueryParam params[] = { struct GNUNET_PQ_QueryParam params[] = {
GNUNET_PQ_query_param_auto_from_type (&refund->coin.coin_pub), GNUNET_PQ_query_param_auto_from_type (&refund->coin.coin_pub),
GNUNET_PQ_query_param_auto_from_type (&refund->merchant_pub), GNUNET_PQ_query_param_auto_from_type (&refund->details.merchant_pub),
GNUNET_PQ_query_param_auto_from_type (&refund->merchant_sig), GNUNET_PQ_query_param_auto_from_type (&refund->details.merchant_sig),
GNUNET_PQ_query_param_auto_from_type (&refund->h_contract_terms), GNUNET_PQ_query_param_auto_from_type (&refund->details.h_contract_terms),
GNUNET_PQ_query_param_uint64 (&refund->rtransaction_id), GNUNET_PQ_query_param_uint64 (&refund->details.rtransaction_id),
TALER_PQ_query_param_amount (&refund->refund_amount), TALER_PQ_query_param_amount (&refund->details.refund_amount),
GNUNET_PQ_query_param_end GNUNET_PQ_query_param_end
}; };
(void) cls; (void) cls;
GNUNET_assert (GNUNET_YES == GNUNET_assert (GNUNET_YES ==
TALER_amount_cmp_currency (&refund->refund_amount, TALER_amount_cmp_currency (&refund->details.refund_amount,
&refund->refund_fee)); &refund->details.refund_fee));
return GNUNET_PQ_eval_prepared_non_select (session->conn, return GNUNET_PQ_eval_prepared_non_select (session->conn,
"insert_refund", "insert_refund",
params); params);
@ -4296,12 +4298,11 @@ add_coin_deposit (void *cls,
for (unsigned int i = 0; i < num_results; i++) for (unsigned int i = 0; i < num_results; i++)
{ {
struct TALER_EXCHANGEDB_Deposit *deposit; struct TALER_EXCHANGEDB_DepositListEntry *deposit;
struct TALER_EXCHANGEDB_TransactionList *tl; struct TALER_EXCHANGEDB_TransactionList *tl;
enum GNUNET_DB_QueryStatus qs;
uint64_t serial_id; uint64_t serial_id;
deposit = GNUNET_new (struct TALER_EXCHANGEDB_Deposit); deposit = GNUNET_new (struct TALER_EXCHANGEDB_DepositListEntry);
{ {
struct GNUNET_PQ_ResultSpec rs[] = { struct GNUNET_PQ_ResultSpec rs[] = {
TALER_PQ_RESULT_SPEC_AMOUNT ("amount_with_fee", TALER_PQ_RESULT_SPEC_AMOUNT ("amount_with_fee",
@ -4339,24 +4340,12 @@ add_coin_deposit (void *cls,
chc->status = GNUNET_DB_STATUS_HARD_ERROR; chc->status = GNUNET_DB_STATUS_HARD_ERROR;
return; return;
} }
deposit->coin.coin_pub = *chc->coin_pub;
} }
tl = GNUNET_new (struct TALER_EXCHANGEDB_TransactionList); tl = GNUNET_new (struct TALER_EXCHANGEDB_TransactionList);
tl->next = chc->head; tl->next = chc->head;
tl->type = TALER_EXCHANGEDB_TT_DEPOSIT; tl->type = TALER_EXCHANGEDB_TT_DEPOSIT;
tl->details.deposit = deposit; tl->details.deposit = deposit;
tl->serial_id = serial_id; tl->serial_id = serial_id;
qs = postgres_get_known_coin (chc->db_cls,
chc->session,
chc->coin_pub,
&deposit->coin);
if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != qs)
{
GNUNET_break (GNUNET_DB_STATUS_SOFT_ERROR == qs);
GNUNET_free (deposit);
chc->status = qs;
return;
}
chc->head = tl; chc->head = tl;
} }
} }
@ -4380,21 +4369,20 @@ add_coin_melt (void *cls,
for (unsigned int i = 0; i<num_results; i++) for (unsigned int i = 0; i<num_results; i++)
{ {
struct TALER_EXCHANGEDB_RefreshMelt *melt; struct TALER_EXCHANGEDB_RefreshMeltListEntry *melt;
struct TALER_EXCHANGEDB_TransactionList *tl; struct TALER_EXCHANGEDB_TransactionList *tl;
enum GNUNET_DB_QueryStatus qs;
uint64_t serial_id; uint64_t serial_id;
melt = GNUNET_new (struct TALER_EXCHANGEDB_RefreshMelt); melt = GNUNET_new (struct TALER_EXCHANGEDB_RefreshMeltListEntry);
{ {
struct GNUNET_PQ_ResultSpec rs[] = { struct GNUNET_PQ_ResultSpec rs[] = {
GNUNET_PQ_result_spec_auto_from_type ("rc", GNUNET_PQ_result_spec_auto_from_type ("rc",
&melt->session.rc), &melt->rc),
/* oldcoin_index not needed */ /* oldcoin_index not needed */
GNUNET_PQ_result_spec_auto_from_type ("old_coin_sig", GNUNET_PQ_result_spec_auto_from_type ("old_coin_sig",
&melt->session.coin_sig), &melt->coin_sig),
TALER_PQ_RESULT_SPEC_AMOUNT ("amount_with_fee", TALER_PQ_RESULT_SPEC_AMOUNT ("amount_with_fee",
&melt->session.amount_with_fee), &melt->amount_with_fee),
TALER_PQ_RESULT_SPEC_AMOUNT ("fee_refresh", TALER_PQ_RESULT_SPEC_AMOUNT ("fee_refresh",
&melt->melt_fee), &melt->melt_fee),
GNUNET_PQ_result_spec_uint64 ("melt_serial_id", GNUNET_PQ_result_spec_uint64 ("melt_serial_id",
@ -4412,25 +4400,12 @@ add_coin_melt (void *cls,
chc->status = GNUNET_DB_STATUS_HARD_ERROR; chc->status = GNUNET_DB_STATUS_HARD_ERROR;
return; return;
} }
melt->session.coin.coin_pub = *chc->coin_pub;
} }
tl = GNUNET_new (struct TALER_EXCHANGEDB_TransactionList); tl = GNUNET_new (struct TALER_EXCHANGEDB_TransactionList);
tl->next = chc->head; tl->next = chc->head;
tl->type = TALER_EXCHANGEDB_TT_REFRESH_MELT; tl->type = TALER_EXCHANGEDB_TT_REFRESH_MELT;
tl->details.melt = melt; tl->details.melt = melt;
tl->serial_id = serial_id; tl->serial_id = serial_id;
/* FIXME: integrate via JOIN in main select, instead of using separate query */
qs = postgres_get_known_coin (chc->db_cls,
chc->session,
chc->coin_pub,
&melt->session.coin);
if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != qs)
{
GNUNET_break (GNUNET_DB_STATUS_SOFT_ERROR == qs);
GNUNET_free (melt);
chc->status = qs;
return;
}
chc->head = tl; chc->head = tl;
} }
} }
@ -4454,12 +4429,11 @@ add_coin_refund (void *cls,
for (unsigned int i = 0; i<num_results; i++) for (unsigned int i = 0; i<num_results; i++)
{ {
struct TALER_EXCHANGEDB_Refund *refund; struct TALER_EXCHANGEDB_RefundListEntry *refund;
struct TALER_EXCHANGEDB_TransactionList *tl; struct TALER_EXCHANGEDB_TransactionList *tl;
enum GNUNET_DB_QueryStatus qs;
uint64_t serial_id; uint64_t serial_id;
refund = GNUNET_new (struct TALER_EXCHANGEDB_Refund); refund = GNUNET_new (struct TALER_EXCHANGEDB_RefundListEntry);
{ {
struct GNUNET_PQ_ResultSpec rs[] = { struct GNUNET_PQ_ResultSpec rs[] = {
GNUNET_PQ_result_spec_auto_from_type ("merchant_pub", GNUNET_PQ_result_spec_auto_from_type ("merchant_pub",
@ -4489,24 +4463,12 @@ add_coin_refund (void *cls,
chc->status = GNUNET_DB_STATUS_HARD_ERROR; chc->status = GNUNET_DB_STATUS_HARD_ERROR;
return; return;
} }
refund->coin.coin_pub = *chc->coin_pub;
} }
tl = GNUNET_new (struct TALER_EXCHANGEDB_TransactionList); tl = GNUNET_new (struct TALER_EXCHANGEDB_TransactionList);
tl->next = chc->head; tl->next = chc->head;
tl->type = TALER_EXCHANGEDB_TT_REFUND; tl->type = TALER_EXCHANGEDB_TT_REFUND;
tl->details.refund = refund; tl->details.refund = refund;
tl->serial_id = serial_id; tl->serial_id = serial_id;
qs = postgres_get_known_coin (chc->db_cls,
chc->session,
chc->coin_pub,
&refund->coin);
if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != qs)
{
GNUNET_break (GNUNET_DB_STATUS_SOFT_ERROR == qs);
GNUNET_free (refund);
chc->status = qs;
return;
}
chc->head = tl; chc->head = tl;
} }
} }
@ -4530,11 +4492,11 @@ add_old_coin_payback (void *cls,
for (unsigned int i = 0; i<num_results; i++) for (unsigned int i = 0; i<num_results; i++)
{ {
struct TALER_EXCHANGEDB_PaybackRefresh *payback; struct TALER_EXCHANGEDB_PaybackRefreshListEntry *payback;
struct TALER_EXCHANGEDB_TransactionList *tl; struct TALER_EXCHANGEDB_TransactionList *tl;
uint64_t serial_id; uint64_t serial_id;
payback = GNUNET_new (struct TALER_EXCHANGEDB_PaybackRefresh); payback = GNUNET_new (struct TALER_EXCHANGEDB_PaybackRefreshListEntry);
{ {
struct GNUNET_PQ_ResultSpec rs[] = { struct GNUNET_PQ_ResultSpec rs[] = {
GNUNET_PQ_result_spec_auto_from_type ("coin_pub", GNUNET_PQ_result_spec_auto_from_type ("coin_pub",
@ -4597,28 +4559,23 @@ add_coin_payback (void *cls,
for (unsigned int i = 0; i<num_results; i++) for (unsigned int i = 0; i<num_results; i++)
{ {
struct TALER_EXCHANGEDB_Payback *payback; struct TALER_EXCHANGEDB_PaybackListEntry *payback;
struct TALER_EXCHANGEDB_TransactionList *tl; struct TALER_EXCHANGEDB_TransactionList *tl;
uint64_t serial_id; uint64_t serial_id;
payback = GNUNET_new (struct TALER_EXCHANGEDB_Payback); payback = GNUNET_new (struct TALER_EXCHANGEDB_PaybackListEntry);
{ {
struct GNUNET_PQ_ResultSpec rs[] = { struct GNUNET_PQ_ResultSpec rs[] = {
TALER_PQ_RESULT_SPEC_AMOUNT ("amount",
&payback->value),
GNUNET_PQ_result_spec_auto_from_type ("reserve_pub", GNUNET_PQ_result_spec_auto_from_type ("reserve_pub",
&payback->reserve_pub), &payback->reserve_pub),
GNUNET_PQ_result_spec_auto_from_type ("coin_blind",
&payback->coin_blind),
GNUNET_PQ_result_spec_auto_from_type ("coin_sig", GNUNET_PQ_result_spec_auto_from_type ("coin_sig",
&payback->coin_sig), &payback->coin_sig),
GNUNET_PQ_result_spec_auto_from_type ("coin_blind",
&payback->coin_blind),
TALER_PQ_RESULT_SPEC_AMOUNT ("amount",
&payback->value),
TALER_PQ_result_spec_absolute_time ("timestamp", TALER_PQ_result_spec_absolute_time ("timestamp",
&payback->timestamp), &payback->timestamp),
GNUNET_PQ_result_spec_auto_from_type ("denom_pub_hash",
&payback->coin.denom_pub_hash),
GNUNET_PQ_result_spec_rsa_signature ("denom_sig",
&payback->coin.denom_sig.
rsa_signature),
GNUNET_PQ_result_spec_uint64 ("payback_uuid", GNUNET_PQ_result_spec_uint64 ("payback_uuid",
&serial_id), &serial_id),
GNUNET_PQ_result_spec_end GNUNET_PQ_result_spec_end
@ -4634,7 +4591,6 @@ add_coin_payback (void *cls,
chc->status = GNUNET_DB_STATUS_HARD_ERROR; chc->status = GNUNET_DB_STATUS_HARD_ERROR;
return; return;
} }
payback->coin.coin_pub = *chc->coin_pub;
} }
tl = GNUNET_new (struct TALER_EXCHANGEDB_TransactionList); tl = GNUNET_new (struct TALER_EXCHANGEDB_TransactionList);
tl->next = chc->head; tl->next = chc->head;
@ -4664,11 +4620,11 @@ add_coin_payback_refresh (void *cls,
for (unsigned int i = 0; i<num_results; i++) for (unsigned int i = 0; i<num_results; i++)
{ {
struct TALER_EXCHANGEDB_PaybackRefresh *payback; struct TALER_EXCHANGEDB_PaybackRefreshListEntry *payback;
struct TALER_EXCHANGEDB_TransactionList *tl; struct TALER_EXCHANGEDB_TransactionList *tl;
uint64_t serial_id; uint64_t serial_id;
payback = GNUNET_new (struct TALER_EXCHANGEDB_PaybackRefresh); payback = GNUNET_new (struct TALER_EXCHANGEDB_PaybackRefreshListEntry);
{ {
struct GNUNET_PQ_ResultSpec rs[] = { struct GNUNET_PQ_ResultSpec rs[] = {
GNUNET_PQ_result_spec_auto_from_type ("old_coin_pub", GNUNET_PQ_result_spec_auto_from_type ("old_coin_pub",
@ -6066,19 +6022,19 @@ refunds_serial_helper_cb (void *cls,
uint64_t rowid; uint64_t rowid;
struct GNUNET_PQ_ResultSpec rs[] = { struct GNUNET_PQ_ResultSpec rs[] = {
GNUNET_PQ_result_spec_auto_from_type ("merchant_pub", GNUNET_PQ_result_spec_auto_from_type ("merchant_pub",
&refund.merchant_pub), &refund.details.merchant_pub),
GNUNET_PQ_result_spec_auto_from_type ("merchant_sig", GNUNET_PQ_result_spec_auto_from_type ("merchant_sig",
&refund.merchant_sig), &refund.details.merchant_sig),
GNUNET_PQ_result_spec_auto_from_type ("h_contract_terms", GNUNET_PQ_result_spec_auto_from_type ("h_contract_terms",
&refund.h_contract_terms), &refund.details.h_contract_terms),
GNUNET_PQ_result_spec_uint64 ("rtransaction_id", GNUNET_PQ_result_spec_uint64 ("rtransaction_id",
&refund.rtransaction_id), &refund.details.rtransaction_id),
GNUNET_PQ_result_spec_rsa_public_key ("denom_pub", GNUNET_PQ_result_spec_rsa_public_key ("denom_pub",
&denom_pub.rsa_public_key), &denom_pub.rsa_public_key),
GNUNET_PQ_result_spec_auto_from_type ("coin_pub", GNUNET_PQ_result_spec_auto_from_type ("coin_pub",
&refund.coin.coin_pub), &refund.coin.coin_pub),
TALER_PQ_RESULT_SPEC_AMOUNT ("amount_with_fee", TALER_PQ_RESULT_SPEC_AMOUNT ("amount_with_fee",
&refund.refund_amount), &refund.details.refund_amount),
GNUNET_PQ_result_spec_uint64 ("refund_serial_id", GNUNET_PQ_result_spec_uint64 ("refund_serial_id",
&rowid), &rowid),
GNUNET_PQ_result_spec_end GNUNET_PQ_result_spec_end
@ -6098,11 +6054,11 @@ refunds_serial_helper_cb (void *cls,
rowid, rowid,
&denom_pub, &denom_pub,
&refund.coin.coin_pub, &refund.coin.coin_pub,
&refund.merchant_pub, &refund.details.merchant_pub,
&refund.merchant_sig, &refund.details.merchant_sig,
&refund.h_contract_terms, &refund.details.h_contract_terms,
refund.rtransaction_id, refund.details.rtransaction_id,
&refund.refund_amount); &refund.details.refund_amount);
GNUNET_PQ_cleanup_result (rs); GNUNET_PQ_cleanup_result (rs);
if (GNUNET_OK != ret) if (GNUNET_OK != ret)
break; break;

65
src/exchangedb/test_exchangedb.c
View File

@ -1432,36 +1432,36 @@ check_refund_cb (void *cls,
const struct TALER_EXCHANGEDB_Refund *refund = cls; const struct TALER_EXCHANGEDB_Refund *refund = cls;
if (0 != GNUNET_memcmp (merchant_pub, if (0 != GNUNET_memcmp (merchant_pub,
&refund->merchant_pub)) &refund->details.merchant_pub))
{ {
GNUNET_break (0); GNUNET_break (0);
result = 66; result = 66;
} }
if (0 != GNUNET_memcmp (merchant_sig, if (0 != GNUNET_memcmp (merchant_sig,
&refund->merchant_sig)) &refund->details.merchant_sig))
{ {
GNUNET_break (0); GNUNET_break (0);
result = 66; result = 66;
} }
if (0 != GNUNET_memcmp (h_contract, if (0 != GNUNET_memcmp (h_contract,
&refund->h_contract_terms)) &refund->details.h_contract_terms))
{ {
GNUNET_break (0); GNUNET_break (0);
result = 66; result = 66;
} }
if (rtransaction_id != refund->rtransaction_id) if (rtransaction_id != refund->details.rtransaction_id)
{ {
GNUNET_break (0); GNUNET_break (0);
result = 66; result = 66;
} }
if (0 != TALER_amount_cmp (amount_with_fee, if (0 != TALER_amount_cmp (amount_with_fee,
&refund->refund_amount)) &refund->details.refund_amount))
{ {
GNUNET_break (0); GNUNET_break (0);
result = 66; result = 66;
} }
if (0 != TALER_amount_cmp (refund_fee, if (0 != TALER_amount_cmp (refund_fee,
&refund->refund_fee)) &refund->details.refund_fee))
{ {
GNUNET_break (0); GNUNET_break (0);
result = 66; result = 66;
@ -1925,7 +1925,10 @@ run (void *cls)
FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS != FAILIF (GNUNET_DB_STATUS_SUCCESS_NO_RESULTS !=
plugin->test_deposit_done (plugin->cls, plugin->test_deposit_done (plugin->cls,
session, session,
&deposit)); &deposit.coin.coin_pub,
&deposit.merchant_pub,
&deposit.h_contract_terms,
&deposit.h_wire));
FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
plugin->mark_deposit_done (plugin->cls, plugin->mark_deposit_done (plugin->cls,
session, session,
@ -1936,7 +1939,10 @@ run (void *cls)
FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
plugin->test_deposit_done (plugin->cls, plugin->test_deposit_done (plugin->cls,
session, session,
&deposit)); &deposit.coin.coin_pub,
&deposit.merchant_pub,
&deposit.h_contract_terms,
&deposit.h_wire));
result = 10; result = 10;
deposit2 = deposit; deposit2 = deposit;
@ -1966,13 +1972,14 @@ run (void *cls)
/* test insert_refund! */ /* test insert_refund! */
refund.coin = deposit.coin; refund.coin = deposit.coin;
refund.merchant_pub = deposit.merchant_pub; refund.details.merchant_pub = deposit.merchant_pub;
RND_BLK (&refund.merchant_sig); RND_BLK (&refund.details.merchant_sig);
refund.h_contract_terms = deposit.h_contract_terms; refund.details.h_contract_terms = deposit.h_contract_terms;
refund.rtransaction_id = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, refund.details.rtransaction_id
UINT64_MAX); = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
refund.refund_amount = deposit.amount_with_fee; UINT64_MAX);
refund.refund_fee = fee_refund; refund.details.refund_amount = deposit.amount_with_fee;
refund.details.refund_fee = fee_refund;
FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT != FAILIF (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT !=
plugin->insert_refund (plugin->cls, plugin->insert_refund (plugin->cls,
session, session,
@ -2064,11 +2071,8 @@ run (void *cls)
{ {
case TALER_EXCHANGEDB_TT_DEPOSIT: case TALER_EXCHANGEDB_TT_DEPOSIT:
{ {
struct TALER_EXCHANGEDB_Deposit *have = tlp->details.deposit; struct TALER_EXCHANGEDB_DepositListEntry *have = tlp->details.deposit;
FAILIF (0 != memcmp (&have->coin.coin_pub,
&deposit.coin.coin_pub,
sizeof (struct TALER_CoinSpendPublicKeyP)));
/* Note: we're not comparing the denomination keys, as there is /* Note: we're not comparing the denomination keys, as there is
still the question of whether we should even bother exporting still the question of whether we should even bother exporting
them here. */ them here. */
@ -2108,31 +2112,29 @@ run (void *cls)
#endif #endif
case TALER_EXCHANGEDB_TT_REFUND: case TALER_EXCHANGEDB_TT_REFUND:
{ {
struct TALER_EXCHANGEDB_Refund *have = tlp->details.refund; struct TALER_EXCHANGEDB_RefundListEntry *have = tlp->details.refund;
FAILIF (0 != memcmp (&have->coin.coin_pub,
&refund.coin.coin_pub,
sizeof (struct TALER_CoinSpendPublicKeyP)));
/* Note: we're not comparing the denomination keys, as there is /* Note: we're not comparing the denomination keys, as there is
still the question of whether we should even bother exporting still the question of whether we should even bother exporting
them here. */ them here. */
FAILIF (0 != GNUNET_memcmp (&have->merchant_pub, FAILIF (0 != GNUNET_memcmp (&have->merchant_pub,
&refund.merchant_pub)); &refund.details.merchant_pub));
FAILIF (0 != GNUNET_memcmp (&have->merchant_sig, FAILIF (0 != GNUNET_memcmp (&have->merchant_sig,
&refund.merchant_sig)); &refund.details.merchant_sig));
FAILIF (0 != GNUNET_memcmp (&have->h_contract_terms, FAILIF (0 != GNUNET_memcmp (&have->h_contract_terms,
&refund.h_contract_terms)); &refund.details.h_contract_terms));
FAILIF (have->rtransaction_id != refund.rtransaction_id); FAILIF (have->rtransaction_id != refund.details.rtransaction_id);
FAILIF (0 != TALER_amount_cmp (&have->refund_amount, FAILIF (0 != TALER_amount_cmp (&have->refund_amount,
&refund.refund_amount)); &refund.details.refund_amount));
FAILIF (0 != TALER_amount_cmp (&have->refund_fee, FAILIF (0 != TALER_amount_cmp (&have->refund_fee,
&refund.refund_fee)); &refund.details.refund_fee));
matched |= 4; matched |= 4;
break; break;
} }
case TALER_EXCHANGEDB_TT_PAYBACK: case TALER_EXCHANGEDB_TT_PAYBACK:
{ {
struct TALER_EXCHANGEDB_Payback *payback = tlp->details.payback; struct TALER_EXCHANGEDB_PaybackListEntry *payback =
tlp->details.payback;
FAILIF (0 != GNUNET_memcmp (&payback->coin_sig, FAILIF (0 != GNUNET_memcmp (&payback->coin_sig,
&coin_sig)); &coin_sig));
@ -2140,9 +2142,6 @@ run (void *cls)
&coin_blind)); &coin_blind));
FAILIF (0 != GNUNET_memcmp (&payback->reserve_pub, FAILIF (0 != GNUNET_memcmp (&payback->reserve_pub,
&reserve_pub)); &reserve_pub));
FAILIF (0 != memcmp (&payback->coin.coin_pub,
&deposit.coin.coin_pub,
sizeof (deposit.coin.coin_pub)));
FAILIF (0 != TALER_amount_cmp (&payback->value, FAILIF (0 != TALER_amount_cmp (&payback->value,
&value)); &value));
matched |= 8; matched |= 8;

235
src/include/taler_exchangedb_plugin.h
View File

@ -275,7 +275,8 @@ struct TALER_EXCHANGEDB_CollectableBlindcoin
/** /**
* Information the exchange records about a /payback request. * Information the exchange records about a /payback request
* in a reserve history.
*/ */
struct TALER_EXCHANGEDB_Payback struct TALER_EXCHANGEDB_Payback
{ {
@ -316,13 +317,52 @@ struct TALER_EXCHANGEDB_Payback
/** /**
* Information the exchange records about a /payback-refresh request. * Information the exchange records about a /payback request
* in a coin history.
*/ */
struct TALER_EXCHANGEDB_PaybackRefresh struct TALER_EXCHANGEDB_PaybackListEntry
{ {
/** /**
* Information about the coin that was paid back. * Blinding factor supplied to prove to the exchange that
* the coin came from this reserve.
*/
struct TALER_DenominationBlindingKeyP coin_blind;
/**
* Signature of the coin of type
* #TALER_SIGNATURE_WALLET_COIN_PAYBACK.
*/
struct TALER_CoinSpendSignatureP coin_sig;
/**
* Public key of the reserve the coin was paid back into.
*/
struct TALER_ReservePublicKeyP reserve_pub;
/**
* How much was the coin still worth at this time?
*/
struct TALER_Amount value;
/**
* When did the /payback operation happen?
*/
struct GNUNET_TIME_Absolute timestamp;
};
/**
* Information the exchange records about a /payback-refresh request in
* a coin transaction history.
*/
struct TALER_EXCHANGEDB_PaybackRefreshListEntry
{
/**
* Information about the coin that was paid back
* (NOT the coin we are considering the history of!)
*/ */
struct TALER_CoinPublicInfo coin; struct TALER_CoinPublicInfo coin;
@ -534,22 +574,95 @@ struct TALER_EXCHANGEDB_Deposit
/** /**
* @brief Specification for a /refund operation. The combination of * @brief Specification for a /deposit operation in the
* the coin's public key, the merchant's public key and the * `struct TALER_EXCHANGEDB_TransactionList`.
* transaction ID must be unique. While a coin can (theoretically) be
* deposited at the same merchant twice (with partial spending), the
* merchant must either use a different public key or a different
* transaction ID for the two transactions. The same goes for
* refunds, hence we also have a "rtransaction" ID which is disjoint
* from the transaction ID. The same coin must not be used twice at
* the same merchant for the same transaction or rtransaction ID.
*/ */
struct TALER_EXCHANGEDB_Refund struct TALER_EXCHANGEDB_DepositListEntry
{ {
/** /**
* Information about the coin that is being refunded. * ECDSA signature affirming that the customer intends
* this coin to be deposited at the merchant identified
* by @e h_wire in relation to the proposal data identified
* by @e h_contract_terms.
*/ */
struct TALER_CoinPublicInfo coin; struct TALER_CoinSpendSignatureP csig;
/**
* Public key of the merchant. Enables later identification
* of the merchant in case of a need to rollback transactions.
*/
struct TALER_MerchantPublicKeyP merchant_pub;
/**
* Hash over the proposa data between merchant and customer
* (remains unknown to the Exchange).
*/
struct GNUNET_HashCode h_contract_terms;
/**
* Hash of the (canonical) representation of @e wire, used
* to check the signature on the request. Generated by
* the exchange from the detailed wire data provided by the
* merchant.
*/
struct GNUNET_HashCode h_wire;
/**
* Detailed information about the receiver for executing the transaction.
* Includes URL in payto://-format and salt.
*/
json_t *receiver_wire_account;
/**
* Time when this request was generated. Used, for example, to
* assess when (roughly) the income was achieved for tax purposes.
* Note that the Exchange will only check that the timestamp is not "too
* far" into the future (i.e. several days). The fact that the
* timestamp falls within the validity period of the coin's
* denomination key is irrelevant for the validity of the deposit
* request, as obviously the customer and merchant could conspire to
* set any timestamp. Also, the Exchange must accept very old deposit
* requests, as the merchant might have been unable to transmit the
* deposit request in a timely fashion (so back-dating is not
* prevented).
*/
struct GNUNET_TIME_Absolute timestamp;
/**
* How much time does the merchant have to issue a refund request?
* Zero if refunds are not allowed. After this time, the coin
* cannot be refunded.
*/
struct GNUNET_TIME_Absolute refund_deadline;
/**
* How much time does the merchant have to execute the wire transfer?
* This time is advisory for aggregating transactions, not a hard
* constraint (as the merchant can theoretically pick any time,
* including one in the past).
*/
struct GNUNET_TIME_Absolute wire_deadline;
/**
* Fraction of the coin's remaining value to be deposited, including
* depositing fee (if any). The coin is identified by @e coin_pub.
*/
struct TALER_Amount amount_with_fee;
/**
* Depositing fee.
*/
struct TALER_Amount deposit_fee;
};
/**
* @brief Specification for a /refund operation in a coin's transaction list.
*/
struct TALER_EXCHANGEDB_RefundListEntry
{
/** /**
* Public key of the merchant. * Public key of the merchant.
@ -587,6 +700,32 @@ struct TALER_EXCHANGEDB_Refund
}; };
/**
* @brief Specification for a /refund operation. The combination of
* the coin's public key, the merchant's public key and the
* transaction ID must be unique. While a coin can (theoretically) be
* deposited at the same merchant twice (with partial spending), the
* merchant must either use a different public key or a different
* transaction ID for the two transactions. The same goes for
* refunds, hence we also have a "rtransaction" ID which is disjoint
* from the transaction ID. The same coin must not be used twice at
* the same merchant for the same transaction or rtransaction ID.
*/
struct TALER_EXCHANGEDB_Refund
{
/**
* Information about the coin that is being refunded.
*/
struct TALER_CoinPublicInfo coin;
/**
* Details about the refund.
*/
struct TALER_EXCHANGEDB_RefundListEntry details;
};
/** /**
* @brief Specification for coin in a /refresh/melt operation. * @brief Specification for coin in a /refresh/melt operation.
*/ */
@ -627,7 +766,47 @@ struct TALER_EXCHANGEDB_RefreshSession
/** /**
* Information about a /refresh/melt operation in the transaction history. * Information about a /refresh/melt operation in a coin transaction history.
*/
struct TALER_EXCHANGEDB_RefreshMeltListEntry
{
/**
* Signature over the melting operation.
*/
struct TALER_CoinSpendSignatureP coin_sig;
/**
* Refresh commitment this coin is melted into.
*/
struct TALER_RefreshCommitmentP rc;
/**
* How much value is being melted? This amount includes the fees,
* so the final amount contributed to the melt is this value minus
* the fee for melting the coin. We include the fee in what is
* being signed so that we can verify a reserve's remaining total
* balance without needing to access the respective denomination key
* information each time.
*/
struct TALER_Amount amount_with_fee;
/**
* Melt fee the exchange charged.
*/
struct TALER_Amount melt_fee;
/**
* Index (smaller #TALER_CNC_KAPPA) which the exchange has chosen to not
* have revealed during cut and choose.
*/
uint32_t noreveal_index;
};
/**
* Information about a /refresh/melt operation.
*/ */
struct TALER_EXCHANGEDB_RefreshMelt struct TALER_EXCHANGEDB_RefreshMelt
{ {
@ -744,39 +923,39 @@ struct TALER_EXCHANGEDB_TransactionList
* Details if transaction was a /deposit operation. * Details if transaction was a /deposit operation.
* (#TALER_EXCHANGEDB_TT_DEPOSIT) * (#TALER_EXCHANGEDB_TT_DEPOSIT)
*/ */
struct TALER_EXCHANGEDB_Deposit *deposit; struct TALER_EXCHANGEDB_DepositListEntry *deposit;
/** /**
* Details if transaction was a /refresh/melt operation. * Details if transaction was a /refresh/melt operation.
* (#TALER_EXCHANGEDB_TT_REFRESH_MELT) * (#TALER_EXCHANGEDB_TT_REFRESH_MELT)
*/ */
struct TALER_EXCHANGEDB_RefreshMelt *melt; struct TALER_EXCHANGEDB_RefreshMeltListEntry *melt;
/** /**
* Details if transaction was a /refund operation. * Details if transaction was a /refund operation.
* (#TALER_EXCHANGEDB_TT_REFUND) * (#TALER_EXCHANGEDB_TT_REFUND)
*/ */
struct TALER_EXCHANGEDB_Refund *refund; struct TALER_EXCHANGEDB_RefundListEntry *refund;
/** /**
* Details if transaction was a /payback-refund operation where * Details if transaction was a /payback-refund operation where
* this coin was the OLD coin. * this coin was the OLD coin.
* (#TALER_EXCHANGEDB_TT_OLD_COIN_PAYBACK). * (#TALER_EXCHANGEDB_TT_OLD_COIN_PAYBACK).
*/ */
struct TALER_EXCHANGEDB_PaybackRefresh *old_coin_payback; struct TALER_EXCHANGEDB_PaybackRefreshListEntry *old_coin_payback;
/** /**
* Details if transaction was a /payback operation. * Details if transaction was a /payback operation.
* (#TALER_EXCHANGEDB_TT_PAYBACK) * (#TALER_EXCHANGEDB_TT_PAYBACK)
*/ */
struct TALER_EXCHANGEDB_Payback *payback; struct TALER_EXCHANGEDB_PaybackListEntry *payback;
/** /**
* Details if transaction was a /payback-refund operation where * Details if transaction was a /payback-refund operation where
* this coin was the REFRESHED coin. * this coin was the REFRESHED coin.
* (#TALER_EXCHANGEDB_TT_PAYBACK_REFRESH) * (#TALER_EXCHANGEDB_TT_PAYBACK_REFRESH)
*/ */
struct TALER_EXCHANGEDB_PaybackRefresh *payback_refresh; struct TALER_EXCHANGEDB_PaybackRefreshListEntry *payback_refresh;
} details; } details;
@ -1790,7 +1969,10 @@ struct TALER_EXCHANGEDB_Plugin
* *
* @param cls the @e cls of this struct with the plugin-specific state * @param cls the @e cls of this struct with the plugin-specific state
* @param session connection to the database * @param session connection to the database
* @param deposit the deposit to check * @param coin_pub the coin to check for deposit
* @param merchant_pub merchant to receive the deposit
* @param h_contract_terms contract terms of the deposit
* @param h_wire hash of the merchant's wire details
* @return #GNUNET_DB_STATUS_SUCCESS_ONE_RESULT if is is marked done, * @return #GNUNET_DB_STATUS_SUCCESS_ONE_RESULT if is is marked done,
* #GNUNET_DB_STATUS_SUCCESS_NO_RESULTS if not, * #GNUNET_DB_STATUS_SUCCESS_NO_RESULTS if not,
* otherwise transaction error status (incl. deposit unknown) * otherwise transaction error status (incl. deposit unknown)
@ -1798,7 +1980,10 @@ struct TALER_EXCHANGEDB_Plugin
enum GNUNET_DB_QueryStatus enum GNUNET_DB_QueryStatus
(*test_deposit_done)(void *cls, (*test_deposit_done)(void *cls,
struct TALER_EXCHANGEDB_Session *session, struct TALER_EXCHANGEDB_Session *session,
const struct TALER_EXCHANGEDB_Deposit *deposit); const struct TALER_CoinSpendPublicKeyP *coin_pub,
const struct TALER_MerchantPublicKeyP *merchant_pub,
const struct GNUNET_HashCode *h_contract_terms,
const struct GNUNET_HashCode *h_wire);
/** /**